Пример #1
0
        public async Task Cleanup()
        {
            var currentUser = await _client.GetCurrentUserAsync();

            var changeResponse =
                await _client.SetActiveWorkspaceFor(currentUser.Data.Id, DefaultWorkspaceFixture.DefaultWorkspaceId);

            changeResponse.IsSuccessful.Should().BeTrue();
            var workspaceResponse = await _client.DeleteWorkspaceAsync(_workspaceId);

            workspaceResponse.IsSuccessful.Should().BeTrue();
        }
Пример #2
0
        public async Task GetDetailedReportAsync_ShouldReturnDetailedReportDto()
        {
            var now    = DateTimeOffset.UtcNow;
            var client = await SetupHelper.CreateTestClientAsync(_client, _workspaceId);

            var project = await SetupHelper.CreateTestProjectAsync(_client, _workspaceId, client.Id);

            await SetupHelper.CreateTestTimeEntryAsync(_client, _workspaceId, now, project.Id);

            var userResponse = await _client.GetCurrentUserAsync();

            userResponse.IsSuccessful.Should().BeTrue();

            var nowWithTimeZone = DateTimeHelper.ConvertToTimeZone(userResponse.Data.Settings.TimeZone, now);

            var detailedReportRequest = new DetailedReportRequest {
                ExportType         = ExportType.JSON,
                DateRangeStart     = nowWithTimeZone.AddMinutes(-2),
                DateRangeEnd       = nowWithTimeZone.AddMinutes(2),
                SortOrder          = SortOrderType.DESCENDING,
                Description        = String.Empty,
                Rounding           = false,
                WithoutDescription = false,
                AmountShown        = AmountShownType.EARNED,
                Clients            = new ClientsFilterDto {
                    Contains = ContainsType.CONTAINS,
                    Ids      = new List <string> {
                        client.Id
                    },
                    Status = StatusType.ACTIVE
                },
                DetailedFilter = new DetailedFilterDto {
                    SortColumn = SortColumnType.DATE,
                    Page       = 1,
                    PageSize   = 50
                },
                TimeZone = userResponse.Data.Settings.TimeZone
            };

            var getDetailedReportResult = await _client.GetDetailedReportAsync(_workspaceId, detailedReportRequest);

            getDetailedReportResult.IsSuccessful.Should().BeTrue();
            getDetailedReportResult.Data.Should().NotBeNull();
            getDetailedReportResult.Data.TimeEntries.Should().HaveCountGreaterOrEqualTo(1);

            // Cleanup
            var deleteProject = await _client.ArchiveAndDeleteProject(_workspaceId, project.Id);

            deleteProject.IsSuccessful.Should().BeTrue();
        }
Пример #3
0
        public async Task GetCurrentUser_ShouldReturnCurrentUser()
        {
            var response = await _client.GetCurrentUserAsync();

            response.IsSuccessful.Should().BeTrue();
            response.Data.Should().NotBeNull();
        }
Пример #4
0
        public async Task CreateTimeEntryAsyncForAnotherUser_ShouldCreteTimeEntryAndReturnTimeEntryDtoImpl()
        {
            var response = await _client.GetCurrentUserAsync();

            response.IsSuccessful.Should().BeTrue();
            response.Data.Should().NotBeNull();

            var now = DateTimeOffset.UtcNow;
            var timeEntryRequest = new TimeEntryRequest
            {
                Start = now,
                End   = now.AddHours(1)
            };
            var userId       = response.Data.Id; // Using my own user for testing
            var createResult = await _client.CreateTimeEntryForAnotherUserAsync(_workspaceId, userId, timeEntryRequest);

            createResult.IsSuccessful.Should().BeTrue();
            createResult.Data.Should().NotBeNull();
            createResult.Data.TimeInterval.Start.Should().BeCloseTo(now, 1.Seconds());
        }
Пример #5
0
        public async Task FindAllTimeEntriesForUserAsync_ShouldReturnTimeEntryDtoImplList()
        {
            var now = DateTimeOffset.UtcNow;
            var timeEntryRequest = new TimeEntryRequest
            {
                Start       = now,
                Description = ""
            };
            var createResult = await _client.CreateTimeEntryAsync(_workspaceId, timeEntryRequest);

            createResult.IsSuccessful.Should().BeTrue();

            var userResponse = await _client.GetCurrentUserAsync();

            userResponse.IsSuccessful.Should().BeTrue();


            var response = await _client.FindAllTimeEntriesForUserAsync(_workspaceId, userResponse.Data.Id,
                                                                        start : DateTimeOffset.Now.AddDays(-1),
                                                                        end : DateTimeOffset.Now.AddDays(1));

            response.IsSuccessful.Should().BeTrue();
            response.Data.Should().ContainEquivalentOf(createResult.Data);
        }
        public async Task CreateWorkspace_ShouldCreateWorkspace()
        {
            var response = await _client.CreateWorkspaceAsync(new WorkspaceRequest()
            {
                Name = "CreateWorkspaceTest"
            });

            response.IsSuccessful.Should().BeTrue();

            // Cleanup
            var id = response.Data.Id;

            var currentUser = await _client.GetCurrentUserAsync();

            var changeWorkspaceResponse =
                await _client.SetActiveWorkspaceFor(currentUser.Data.Id, DefaultWorkspaceFixture.DefaultWorkspaceId);

            changeWorkspaceResponse.IsSuccessful.Should().BeTrue();
            var del = await _client.DeleteWorkspaceAsync(id);

            del.IsSuccessful.Should().BeTrue();
        }