T-Банк выходит на арену: разбираем T-Lite и T-Pro в боевых условиях

#!/bin/bash

# Определяем базовую директорию

BASE_DIR="/home/marat/Downloads"

# Создаем директории для разных типов файлов

IMAGES_DIR="$BASE_DIR/images"

PDFS_DIR="$BASE_DIR/pdfs"

VIDEOS_DIR="$BASE_DIR/videos"

# Функция для создания директории, если она не существует

create_dir() {

    if [ ! -d "$1" ]; then

        mkdir -p "$1"

        echo "Создана директория: $1"

    else

        echo "Директория уже существует: $1"

    fi

}

# Создаем необходимые директории

create_dir "$IMAGES_DIR"

create_dir "$PDFS_DIR"

create_dir "$VIDEOS_DIR"

# Функция для копирования файлов

copy_files() {

    local source_pattern="$1"

    local dest_dir="$2"

    local file_type="$3"

    

    # Находим файлы и копируем их

    find "$BASE_DIR" -maxdepth 1 -type f -iname "$source_pattern" -exec cp -v {} "$dest_dir/" ;

    

    # Проверяем, были ли скопированы файлы

    if [ $? -eq 0 ]; then

        echo "Файлы типа $file_type скопированы в $dest_dir"

    else

        echo "Не найдены файлы типа $file_type или произошла ошибка при копировании"

    fi

}

# Копируем изображения (PNG и JPG)

copy_files "*.png" "$IMAGES_DIR" "PNG"

copy_files "*.jpg" "$IMAGES_DIR" "JPG"

copy_files "*.jpeg" "$IMAGES_DIR" "JPEG"

# Копируем PDF файлы

copy_files "*.pdf" "$PDFS_DIR" "PDF"

# Копируем видео файлы

copy_files "*.mp4" "$VIDEOS_DIR" "MP4"

echo "Сортировка файлов завершена!"

#!/bin/bash

# Определяем базовую директорию

BASE_DIR="/home/marat/Downloads"

# Создаем необходимые поддиректории, если они не существуют

mkdir -p "$BASE_DIR/images"

mkdir -p "$BASE_DIR/pdf"

mkdir -p "$BASE_DIR/videos"

# Копируем файлы в соответствующие папки

echo "Копирование изображений (PNG и JPG)..."

find "$BASE_DIR" -maxdepth 1 ( -iname "*.png" -o -iname "*.jpg" -o -iname "*.jpeg" ) -exec cp {} "$BASE_DIR/images/" ;

echo "Копирование PDF файлов..."

find "$BASE_DIR" -maxdepth 1 -iname "*.pdf" -exec cp {} "$BASE_DIR/pdf/" ;

echo "Копирование видео (MP4) файлов..."

find "$BASE_DIR" -maxdepth 1 -iname "*.mp4" -exec cp {} "$BASE_DIR/videos/" ;

echo "Организация завершена."

#!/bin/bash

# Указание пути к папке Downloads

DOWNLOADS_DIR="/home/marat/Downloads"

# Создание папок для PNG/JPG, PDF и MP4 файлов

mkdir -p "$DOWNLOADS_DIR/Images"

mkdir -p "$DOWNLOADS_DIR/Documents"

mkdir -p "$DOWNLOADS_DIR/Videos"

# Копирование PNG и JPG файлов в папку Images

find "$DOWNLOADS_DIR" -maxdepth 1 -type f ( -iname "*.png" -o -iname "*.jpg" -o -iname "*.jpeg" ) -exec mv {} "$DOWNLOADS_DIR/Images/" ;

# Копирование PDF файлов в папку Documents

find "$DOWNLOADS_DIR" -maxdepth 1 -type f -iname "*.pdf" -exec mv {} "$DOWNLOADS_DIR/Documents/" ;

# Копирование MP4 файлов в папку Videos

find "$DOWNLOADS_DIR" -maxdepth 1 -type f -iname "*.mp4" -exec mv {} "$DOWNLOADS_DIR/Videos/" ;

echo "Файлы успешно распределены по папкам!"

#!/bin/bash

# Путь к Downloads

downloads_dir="/home/marat/Downloads"

# Проверяем существование директории и создаем её если не существует

if [ ! -d "$downloads_dir" ]; then

    echo "Directory $downloads_dir does not exist. Creating it..."

    mkdir "$downloads_dir"

fi

# Создаем папки для различных типов файлов

mkdir -p "$downloads_dir"/PNG_JPG

mkdir -p "$downloads_dir"/PDF

mkdir -p "$downloads_dir"/MP4

# Функция для копирования файлов по расширению в соответствующие папки

move_files() {

    local extension="$1"

    local target_dir="$2"

    for file in "$downloads_dir"/*."$extension"; do

        if [ -f "$file" ]; then

            echo "Moving $file to $target_dir..."

            mv -v "$file" "$downloads_dir/$target_dir/"

        fi

    done

}

# Копируем файлы по расширениям

move_files "png" "PNG_JPG"

move_files "jpg" "PNG_JPG"

move_files "pdf" "PDF"

move_files "mp4" "MP4"

echo "All files have been moved to the respective directories."

// Начнём с сущности пользователя — классика для любого приложения

@Entity(tableName = "users")

data class User(

    @PrimaryKey val uid: Int,

    @ColumnInfo(name = "first_name") val firstName: String,

    @ColumnInfo(name = "last_name") val lastName: String,

    @ColumnInfo(name = "email") val email: String,

    @ColumnInfo(name = "created_at") val createdAt: Long = System.currentTimeMillis()

)

// DAO для работы с базой — стандартный набор CRUD-операций

@Dao

interface UserDao {

    @Query("SELECT * FROM users")

    fun getAll(): Flow<List<User>>

    @Query("SELECT * FROM users WHERE uid IN (:userIds)")

    fun loadAllByIds(userIds: IntArray): Flow<List<User>>

    @Insert

    suspend fun insertAll(vararg users: User)

    @Delete

    suspend fun delete(user: User)

}

// Room Database — ничего необычного, просто связываем всё воедино

@Database(entities = [User::class], version = 1)

abstract class AppDatabase : RoomDatabase() {

    abstract fun userDao(): UserDao

}

// Repository — классический паттерн для абстракции работы с данными

class UserRepository @Inject constructor(

    private val userDao: UserDao

) {

    fun getAllUsers(): Flow<List<User>> = userDao.getAll()

    suspend fun addUser(user: User) = userDao.insertAll(user)

    suspend fun deleteUser(user: User) = userDao.delete(user)

}

// И наконец, ViewModel — здесь вся бизнес-логика и состояние UI

@HiltViewModel

class UserViewModel @Inject constructor(

    private val userRepository: UserRepository

) : ViewModel() {

    private val _users = MutableStateFlow<List<User>>(emptyList())

    val users: StateFlow<List<User>> = _users.asStateFlow()

    init {

        viewModelScope.launch {

            userRepository.getAllUsers()

                .collect { users ->

                    _users.value = users

                }

        }

    }

}

@Test

fun initial state should be empty list() = runTest {

    val usersFlow = flowOf(emptyList<User>())

    coEvery { repository.getAllUsers() } returns usersFlow

    viewModel = UserViewModel(repository)

    assertEquals(emptyList<User>(), viewModel.users.value)

}

@Test

fun should collect users from repository() = runTest {

    val testUsers = listOf(

        User(1, "John", "Doe", "john@example.com"),

        User(2, "Jane", "Smith", "jane@example.com")

    )

    val usersFlow = flowOf(testUsers)

    coEvery { repository.getAllUsers() } returns usersFlow

    viewModel = UserViewModel(repository)

    testDispatcher.scheduler.advanceUntilIdle()

    assertEquals(testUsers, viewModel.users.value)

}

@Test

fun should handle repository errors gracefully() = runTest {

    val errorFlow = flow<List<User>> { 

        throw IOException("Network error") 

    }

    coEvery { repository.getAllUsers() } returns errorFlow

    viewModel = UserViewModel(repository)

    testDispatcher.scheduler.advanceUntilIdle()

    assertEquals(emptyList<User>(), viewModel.users.value)

}

import app.cash.turbine.test

import io.mockk.*

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.ExperimentalCoroutinesApi

import kotlinx.coroutines.flow.Flow

import kotlinx.coroutines.flow.MutableStateFlow

import kotlinx.coroutines.flow.flow

import kotlinx.coroutines.test.*

import org.junit.Assert.*

import org.junit.Before

import org.junit.Rule

import org.junit.Test

import org.junit.rules.TestRule

import org.junit.runner.RunWith

import org.mockito.junit.MockitoJUnitRunner

@ExperimentalCoroutinesApi

@RunWith(MockitoJUnitRunner::class)

class UserViewModelTest {

    private lateinit var userRepository: UserRepository

    private lateinit var userViewModel: UserViewModel

    private val testDispatcher = StandardTestDispatcher()

    @get:Rule

    val rule: TestRule = TestCoroutineRule()

    @Before

    fun setup() {

        userRepository = mockk()

        Dispatchers.setMain(testDispatcher)

        userViewModel = UserViewModel(userRepository)

    }

    @Test

    fun should collect users successfully() = runTest {

        val users = listOf(

            User(1, "John", "Doe", "john@example.com"),

            User(2, "Jane", "Doe", "jane@example.com")

        )

        val userFlow: Flow<List<User>> = flow { emit(users) }

        coEvery { userRepository.getAllUsers() } returns userFlow

        

        userViewModel = UserViewModel(userRepository)

        

        userViewModel.users.test {

            assertEquals(users, awaitItem())

        }

    }

    @Test

    fun should handle empty user list() = runTest {

        val emptyUserFlow: Flow<List<User>> = flow { emit(emptyList()) }

        coEvery { userRepository.getAllUsers() } returns emptyUserFlow

        

        userViewModel = UserViewModel(userRepository)

        

        userViewModel.users.test {

            assertTrue(awaitItem().isEmpty())

        }

    }

    @Test

    fun should handle repository error() = runTest {

        val errorFlow: Flow<List<User>> = flow { throw RuntimeException("Database error") }

        coEvery { userRepository.getAllUsers() } returns errorFlow

        

        userViewModel = UserViewModel(userRepository)

        

        userViewModel.users.test {

            assertTrue(awaitItem().isEmpty()) // ViewModel должна обрабатывать ошибки и не падать

        }

    }

}

Разбор тестов:

1. should collect users successfully

   • Проверяет, что UserViewModel корректно собирает пользователей из Flow репозитория.

2. should handle empty user list

   • Убеждается, что UserViewModel корректно обрабатывает пустой список.

3. should handle repository error

   • Симулирует ошибку ^[6] в Flow и проверяет, что UserViewModel не падает.

Используем Turbine для тестирования StateFlow и mockk для мокирования зависимостей. Если что-то улучшить – пиши! 🚀

Анализируя кодовую базу, мы видим, что UserViewModel использует корутины и потоки данных (Flow`) для  

получения списка пользователей из базы данных. Давайте напишем юнит-тесты, чтобы убедиться в правильности  

работы с этими механизмами.

### Шаг 1: Подготовка тестовой среды

Для начала нам нужно подготовить тестовую среду для UserViewModel. Это может включать создание моков и  

инжекцию их в UserViewModel для изоляции тестирования. Мы будем использовать Mockito и Mockk.

### Шаг 2: Написание юнит-тестов

Давайте напишем несколько тестов, чтобы проверить работу UserViewModel.

```kotlin

import androidx.arch.core.executor.testing.InstantTaskExecutorRule

import kotlinx.coroutines.Dispatchers

import kotlinx.coroutines.test.runBlockingTest

import org.junit.Assert.assertEquals

import org.junit.Before

import org.junit.Rule

import org.junit.Test

import org.mockito.kotlin.mock

import org.mockito.kotlin.whenever

class UserViewModelTest {

   @get:Rule

   val instantTaskExecutorRule = InstantTaskExecutorRule()

   private lateinit var userRepositoryMock: UserRepository

   private lateinit var userViewModel: UserViewModel

   @Before

   fun setUp() {

       userRepositoryMock = mock()

       userViewModel = UserViewModel(userRepositoryMock)

   }

   @Test

   fun getAllUsers should return empty list when no users are in database() = runBlockingTest {

       // Given

       val emptyUserList = listOf<User>()

       whenever(userRepositoryMock.getAllUsers()).thenReturn(emptyFlow())

       // When

       val users = userViewModel.users.first()

       // Then

       assertEquals(emptyUserList, users)

   }

   @Test

   fun getAllUsers should return list of users when there are users in database() = runBlockingTest {

       // Given

       val userList = listOf(User(uid = 1, firstName = "John", lastName = "Doe", email =  

"john.doe@example.com"))

       whenever(userRepositoryMock.getAllUsers()).thenReturn(flowOf(userList))

       // When

       val users = userViewModel.users.first()

       // Then

       assertEquals(userList, users)

   }

   private fun flowOf(list: List<User>): Flow<List<User>> {

       return flow {

           emit(list)

       }

   }

   private fun emptyFlow(): Flow<List<User>> {

       return flow {}

   }

}

```

### Объяснение тестов

1. Тест на пустой список пользователей: Мы проверяем, что при отсутствии данных в базе, UserViewModel  

корректно возвращает пустой список.

2. Тест на заполненный список пользователей: В этом тесте мы подменяем реальный поток данных из базы на  

мок-поток с конкретными данными и проверяем, что UserViewModel правильно обрабатывает эти данные.

### Шаг 3: Дополнительные тесты

Мы также можем добавить тесты для работы с ошибками:

```kotlin

@Test

fun getAllUsers should throw exception when repository throws an error() = runBlockingTest {

   // Given

   whenever(userRepositoryMock.getAllUsers()).doReturn(emptyFlow())

   // When & Then

   assertFailsWith<Throwable> {

       userViewModel.users.first()

   }

}

```

### Замечания

- Обработка ошибок: Добавьте обработку ошибок в ваш UserViewModel, чтобы корректно уведомлять  

пользователей о возможных проблемах с базой данных.

  

- Использование TestCoroutineDispatcher: Для более сложного тестирования вы можете использовать  

TestCoroutineDispatcher для контроля выполнения корутин.

```kotlin

private val testDispatcher = TestCoroutineDispatcher()

@Before

fun setup() {

   Dispatchers.setMain(testDispatcher)

}

@AfterEach

fun teardown() {

   testDispatcher.cleanupTestCoroutines()

}

```

Эти тесты помогут вам убедиться, что UserViewModel работает корректно с использованием потоков данных и  

корутин.

Для написания юнит-тестов для UserViewModel, которые включают работу с корутинами, Flow` и обработку ошибок, мы начнем с создания мока (например, используя библиотеку Mockito или MockK)

для UserDao. Затем напишем тесты, чтобы покрыть основные функциональности ViewModel.

### Шаг 1: Подготовка зависимостей и настройка окружения

Убедитесь, что у вас есть необходимые зависимости в вашем build.gradle файле:

```groovy

dependencies {

    implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"

    implementation "androidx.room:room-runtime:$room_version"

    kapt "androidx.room:room-compiler:$room_version"

    testImplementation 'junit:junit:4.13.2'

    testImplementation "org.mockito:mockito-core:4.x.x"

    testImplementation "io.mockk:mockk:1.12.x"

    testImplementation "androidx.arch.core:core-testing:2.1.0" // Для тестирования корутин и Flow

}

```

### Шаг 2: Создание ViewModel

Предположим, у нас есть UserViewModel, которая использует Flow для получения данных из базы:

```kotlin

import androidx.lifecycle.ViewModel

import androidx.lifecycle.viewModelScope

import kotlinx.coroutines.flow.*

import kotlinx.coroutines.launch

class UserViewModel(private val userDao: UserDao) : ViewModel() {

    val users = userDao.getAll().catch { e ->

        emit(emptyList()) // Логика обработки ошибок

    }.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun loadUsersByIds(userIds: IntArray) {

        viewModelScope.launch {

            try {

                userDao.loadAllByIds(userIds).collect { users ->

                    // Обработка списка пользователей по ID

                }

            } catch (e: Exception) {

                // Логика обработки ошибок

            }

        }

    }

    fun addUser(user: User) = viewModelScope.launch {

        try {

            userDao.insert(user)

        } catch (e: Exception) {

            // Обработка исключения

        }

    }

}

```

### Шаг 3: Написание тестов

Теперь мы можем написать юнит-тесты:

```kotlin

import kotlinx.coroutines.ExperimentalCoroutinesApi

import kotlinx.coroutines.flow.flowOf

import kotlinx.coroutines.test.runTest

import org.junit.Assert.assertEquals

import org.junit.Before

import org.junit.Test

import org.mockito.kotlin.*

@OptIn(ExperimentalCoroutinesApi::class)

class UserViewModelTest {

    private lateinit var userDao: UserDao

    private lateinit var viewModel: UserViewModel

    @Before

    fun setUp() {

        userDao = mock()

        viewModel = UserViewModel(userDao)

    }

    @Test

    fun test getAll users() = runTest {

        val userList = listOf(User(1, "John", "Doe", "john@doe.com"))

        whenever(userDao.getAll()).thenReturn(flowOf(userList))

        assertEquals(userList, viewModel.users.first())

    }

    @Test

    fun test loadUsersByIds success() = runTest {

        val userIds = intArrayOf(1, 2)

        val userList = listOf(User(1, "Jane", "Doe", "jane@doe.com"), User(2, "Bob", "Smith", "bob@smith.com"))

        whenever(userDao.loadAllByIds(any())).thenReturn(flowOf(userList))

        viewModel.loadUsersByIds(userIds)

        // Проверка того, что корутинная логика сработала корректно

    }

    @Test

    fun test getAll error handling() = runTest {

        val exception = Exception("Database error")

        whenever(userDao.getAll()).thenReturn(flow { throw exception })

        assertEquals(emptyList<User>(), viewModel.users.first())

    }

    @Test

    fun test addUser success() = runTest {

        val user = User(3, "Alice", "Johnson", "alice@johnson.com")

        viewModel.addUser(user)

        verify(userDao).insert(user)

    }

    @Test

    fun test addUser error handling() = runTest {

        val user = User(4, "Charlie", "Brown", "charlie@brown.com")

        whenever(userDao.insert(any())).thenThrow(RuntimeException("Insert failed"))

        viewModel.addUser(user)

        // Проверить логику обработки ошибок

    }

}

```

### Объяснение

1. runTest: Используется для тестирования корутинных функций в изолированной среде.

2. Mocking: Мы используем mockk для создания мока объекта UserDao, чтобы проверить, как ViewModel взаимодействует с ним.

3. Error handling: Проверяем, что ошибка корректно обрабатывается и заменяется на пустой список или другое подходящее значение.

Таким образом мы обеспечиваем покрытие основных функциональностей ViewModel через тесты.