it('should return same state without mutate it when passing state and some action type', () => {
        // Arrange
        const state: MemberEntity =  { id: 1, login: 'test login', avatar_url: 'test avatar_url' };
        const action = { type: 'some type' };
        deepFreeze(state);

        // Act
        const nextState = memberReducer(state, action);

        // Assert
        expect(nextState).toEqual(
            { id: 1, login: 'test login', avatar_url: 'test avatar_url' },
        );
    });

  it('should return same state when passing an action that is not expected', () => {
    // Arrange
    const originalState: LoginState = new LoginState();
    const action = {
      type: 'NOT_EXPECTED_ACTION_1',
    };
    deepFreeze(originalState);

    // Act
    const newState = loginReducer(originalState, action);

    // Assert
    expect(newState).to.be.equal(originalState);
  });

        'action equals { type: "MEMBER_UI_INPUT", fieldName: "id", value: 2 }', () => {
        let initialState = new MemberState();
        initialState.member.id = 1;

        let action = {
            type: "MEMBER_UI_INPUT",
            fieldName: "id",
            value: 2
        };

        deepFreeze(initialState);
        let finalState = memberReducer(initialState, action);

        expect(finalState.member.id).to.be.equal(2);
    });

  it('should return the current state when action type is uknown', () => {
    // Arrange
    const state = undefined;
    const expectedState = new TrainingTOC();
    const action = {
      type: 'UNKNOWN_ACTION',
    };
    deepFreeze(action);

    // Act
    const newState = trainingTOCReducer(state, action);

    // Assert
    expect(newState).to.be.deep.equals(expectedState);
  });

        'HttpState equals {numberOfCalls: 1, httpCallsInProgress: true} and action equals { type: "HTTP_GET_CALL_COMPLETED" }', () => {
        let initialState = new HttpState();
        initialState.numberOfCalls = 1;
        initialState.httpCallsInProgress = true;

        let action = {
            type: "HTTP_GET_CALL_COMPLETED"
        };

        deepFreeze(initialState);
        let finalState = httpReducer(initialState, action);

        expect(finalState.numberOfCalls).to.be.equal(0);
        expect(finalState.httpCallsInProgress).to.be.false;
    });

        'action equals { type: "MEMBER_SAVE", errors: { isEntityValid: true } }', () => {
        let initialState = new MemberState();

        let action = {
            type: "MEMBER_SAVE",
            errors: {
                isEntityValid: true
            }
        };

        deepFreeze(initialState);
        let finalState = MemberReducer(initialState, action);

        expect(finalState.saveCompleted).to.be.true;
    });

        'action equals { type: "MEMBER_LOAD", member: new MemberEntity() }', () => {
        let initialState = new MemberState();
        initialState.isValid = false;

        let member = new MemberEntity();

        let action = {
            type: "MEMBER_LOAD",
            member: member
        };

        deepFreeze(initialState);
        let finalState = memberReducer(initialState, action);

        expect(finalState.isValid).to.be.true;
    });

    it('should return new array with same items when passing initialState equals [repo1, repo2] and action equals {}', () => {
        let repo1 = new RepoEntity();
        let repo2 = new RepoEntity();

        repo1.name = "test1";
        repo2.name = "test2"

        let initialState : Array<RepoEntity> = [repo1, repo2];
        let action = {};

        deepFreeze(initialState);
        let finalState = reposReducer(initialState, action);

        expect(finalState.length).to.be.equal(2);
        expect(finalState[0].name).to.be.equal("test1");
        expect(finalState[1].name).to.be.equal("test2");
      });