public void Given()
{
const string username = "******";
const string password = "******";
_optOutId = Guid.NewGuid();
_accountReference = "EX0123456";
_receivedAt = DateTime.UtcNow;
_phoneNumber = "44123456789";
var data = new
{
OptOut = new
{
Id = _optOutId,
ReceivedAt = _receivedAt,
AccountReference = _accountReference,
From = new
{
PhoneNumber = _phoneNumber
}
}
};
MockApi.SetEndpoint(new MockEndpoint(200, JsonConvert.SerializeObject(data), "application/json; charset=utf-8"));
var optOutClient = new OptOutsService(MockApi.Url, new EsendexCredentials(username, password));
_result = optOutClient.Add(_accountReference, _phoneNumber);
_request = MockApi.LastRequest;
}
public async Task CreateTaskAsync_ReturnsTask()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.CREATE_TASK)));
var res = await MockApi.Object.CreateTaskAsync("ev:1234567890", "Task Name", 1234);
Assert.NotNull(res);
Assert.NotNull(res.Task.Id);
Assert.NotNull(res.Task.Name);
Assert.NotNull(res.Task.Projects);
Assert.NotEqual(default(int), res.Task.Section);
Assert.NotNull(res.Task.Labels);
Assert.NotEqual(default(int), res.Task.Position);
Assert.NotNull(res.Task.Description);
Assert.NotEqual(default(DateTime), res.Task.DueAt);
Assert.Equal(Models.TaskStatus.OPEN, res.Task.Status);
Assert.NotEqual(default(int), res.Task.Time.Total);
Assert.NotNull(res.Task.Time.Users);
Assert.NotEqual(default(int), res.Task.Estimate.Total);
Assert.Equal(Models.EstimateType.OVERALL, res.Task.Estimate.Type);
Assert.NotNull(res.Task.Estimate.Users);
Assert.Equal("Everhour", res.Task.Attributes[0].Client);
Assert.Equal("hight", res.Task.Attributes[0].Priority);
Assert.Equal(42, res.Task.Metrics[0].Efforts);
Assert.Equal(199, res.Task.Metrics[0].Expenses);
}
public async Task SetProjectBillingByUserRateAsync_ReturnsProject()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.SET_PROJECT_BILLING)));
var users = new List <Models.UserWithRate>()
{
new Models.UserWithRate()
{
Id = 1234, Rate = 10000
},
new Models.UserWithRate()
{
Id = 5678, Rate = 10000
}
};
var res = await MockApi.Object.SetProjectBillingByUserRateAsync("as:1234567890", users);
Assert.NotNull(res);
Assert.NotNull(res.Project.Id);
Assert.NotNull(res.Project.Name);
Assert.NotNull(res.Project.WorkspaceId);
Assert.NotNull(res.Project.Workspace);
Assert.Equal(Models.ProjectType.BOARD, res.Project.Type);
Assert.True(res.Project.Favorite);
Assert.NotNull(res.Project.Users);
Assert.NotNull(res.Project.Budget);
Assert.NotEqual(default(int), res.Project.Budget.Value);
Assert.NotEqual(default(int), res.Project.Budget.Progress);
Assert.Equal(Models.BudgetType.MONEY, res.Project.Budget.Type);
Assert.NotNull(res.Project.Billing);
Assert.Equal(Models.BillingType.FLAT_RATE, res.Project.Billing.Type);
Assert.NotEqual(default(int), res.Project.Billing.Rate);
Assert.NotNull(res.Project.Billing.Users);
}
public async Task ExportTeamTimeAsyncWithParams_ReturnsTeamTime()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.EXPORT_TIME)));
var req = new Models.ExportAllTeamTimeRequest
{
From = DateTime.UtcNow,
To = DateTime.UtcNow.AddDays(1),
Fields = Models.ExportAllTeamTimeField.PROJECT
| Models.ExportAllTeamTimeField.TASK
| Models.ExportAllTeamTimeField.DATE
| Models.ExportAllTeamTimeField.USER
};
var res = await MockApi.Object.ExportAllTeamTimeAsync(req);
Assert.NotNull(res);
Assert.All(res.TeamTimes, e => Assert.NotEqual(default(int), e.Time));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Date));
Assert.All(res.TeamTimes, e => Assert.NotEqual(default(int), e.Time));
Assert.All(res.TeamTimes, e => Assert.NotEqual(default(int), e.User.Id));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.User.Name));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Project.Id));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Project.Name));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Project.Workspace));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Task.Id));
Assert.All(res.TeamTimes, e => Assert.NotNull(e.Task.Name));
Assert.All(res.TeamTimes, e => Assert.Equal(Models.TaskType.TASK, e.Task.Type));
}
public async Task CreateProjectAsyncWithRequest_ReturnsProject()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.CREATE_PROJECT)));
var req = new Models.CreateProjectRequest()
{
Name = "Test Project",
Type = Models.ProjectType.BOARD,
Users = new List <int>()
{
1, 2, 3
}
};
var res = await MockApi.Object.CreateProjectAsync(req);
Assert.NotNull(res);
Assert.NotNull(res.Project.Id);
Assert.NotNull(res.Project.Name);
Assert.NotNull(res.Project.WorkspaceId);
Assert.NotNull(res.Project.Workspace);
Assert.Equal(Models.ProjectType.BOARD, res.Project.Type);
Assert.True(res.Project.Favorite);
Assert.NotNull(res.Project.Users);
Assert.NotNull(res.Project.Budget);
Assert.NotEqual(default(int), res.Project.Budget.Value);
Assert.NotEqual(default(int), res.Project.Budget.Progress);
Assert.Equal(Models.BudgetType.MONEY, res.Project.Budget.Type);
Assert.NotNull(res.Project.Billing);
Assert.Equal(Models.BillingType.FLAT_RATE, res.Project.Billing.Type);
Assert.NotEqual(default(int), res.Project.Billing.Rate);
Assert.NotNull(res.Project.Billing.Users);
}
public async Task ListProjectTasksAsync_ReturnsTasks()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.LIST_PROJECT_TASKS)));
var res = await MockApi.Object.ListProjectTasksAsync("ev:1234567890");
Assert.NotNull(res);
Assert.All(res.Tasks, t => Assert.NotNull(t.Id));
Assert.All(res.Tasks, t => Assert.NotNull(t.Name));
Assert.All(res.Tasks, t => Assert.NotNull(t.Projects));
Assert.All(res.Tasks, t => Assert.NotEqual(default(int), t.Section));
Assert.All(res.Tasks, t => Assert.NotNull(t.Labels));
Assert.All(res.Tasks, t => Assert.NotEqual(default(int), t.Position));
Assert.All(res.Tasks, t => Assert.NotNull(t.Description));
Assert.All(res.Tasks, t => Assert.NotEqual(default(DateTime), t.DueAt));
Assert.All(res.Tasks, t => Assert.Equal(Models.TaskStatus.OPEN, t.Status));
Assert.All(res.Tasks, t => Assert.NotEqual(default(int), t.Time.Total));
Assert.All(res.Tasks, t => Assert.NotNull(t.Time.Users));
Assert.All(res.Tasks, t => Assert.NotEqual(default(int), t.Estimate.Total));
Assert.All(res.Tasks, t => Assert.Equal(Models.EstimateType.OVERALL, t.Estimate.Type));
Assert.All(res.Tasks, t => Assert.NotNull(t.Estimate.Users));
Assert.All(res.Tasks, t => Assert.Equal("Everhour", t.Attributes[0].Client));
Assert.All(res.Tasks, t => Assert.Equal("hight", t.Attributes[0].Priority));
Assert.All(res.Tasks, t => Assert.Equal(42, t.Metrics[0].Efforts));
Assert.All(res.Tasks, t => Assert.Equal(199, t.Metrics[0].Expenses));
}
public void Given()
{
const string username = "******";
const string password = "******";
const string recipient = "44123456789";
var surveyId = Guid.NewGuid();
_errorCode = "survey_problem";
_errorDescription = "There was a problem";
_errorValue = "THIS VALUE";
_errorValue2 = "OTHER VALUE";
var data = new
{
errors = new[]
{
new { code = _errorCode, description = _errorDescription, values = new[] { _errorValue, _errorValue2 } }
}
};
MockApi.SetEndpoint(new MockEndpoint(400,
JsonConvert.SerializeObject(data),
"application/json; charset=utf-8"));
var surveysClient = new SurveysService(MockApi.Url, new EsendexCredentials(username, password));
_result = surveysClient.Send(surveyId, recipient);
}
public async Task DeleteSectionAsync_ReturnsSection()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse()));
var res = await MockApi.Object.DeleteSectionAsync(1234);
Assert.True(res);
}
public async Task DeleteTaskEstimateAsync_ReturnsTask()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse()));
var res = await MockApi.Object.DeleteTaskEstimateAsync("ev:9876543210");
Assert.True(res);
}
public async Task DeleteProjectBillingAsync_ReturnsIsSuucessful()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse()));
var res = await MockApi.Object.DeleteProjectBillingAsync("as:1234567890");
Assert.True(res);
}
public async Task It_calls_service_with_passcode_including_current_date()
{
// Act
await SUT.Launch(CorrectPassphrase);
// Assert
await MockApi.Received(requiredNumberOfCalls : 1)
.WarheadsLaunchAsync(CorrectPasscode);
}
public MockMessageHandler(HttpConfiguration httpConfiguration, MockApi mockApi)
{
if (mockApi == null)
{
throw new ArgumentNullException("mockApi");
}
//InnerHandler = new HttpControllerDispatcher(httpConfiguration);
_mockApi = mockApi;
}
public async Task SetTaskEstimateAsyncByOverAll_ReturnsTask()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.SET_TASK_ESTIMATE)));
var res = await MockApi.Object.SetTaskEstimateAsyncByOverAll("ev:9876543210", 7200);
Assert.NotNull(res);
Assert.NotNull(res.Estimate.Total);
Assert.NotNull(res.Estimate.Type);
Assert.Null(res.Estimate.Users);
}
public async Task ListTeamUsersAsync_ReturnsUsers()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.LIST_USERS)));
var res = await MockApi.Object.ListTeamUsersAsync();
Assert.NotNull(res.Users);
Assert.All(res.Users, user => Assert.NotEqual(default(int), user.Id));
Assert.All(res.Users, user => Assert.Equal(Models.RoleType.ADMIN, user.Role));
Assert.All(res.Users, user => Assert.Equal(Models.UserStatus.ACTIVE, user.Status));
}
public async Task AddTimeToTaskAsyncWithRequest_ReturnsTimeRecord()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.ADD_TIME_TO_TASK)));
var req = new Models.AddTimeToTaskRequest()
{
TaskId = "ev:1234567890",
Time = 3600,
Date = DateTime.UtcNow,
User = 1234
};
var res = await MockApi.Object.AddTimeToTaskAsync(req);
Assert.NotNull(res);
Assert.Equal(2660155, res.TimeRecord.Id);
Assert.Equal(3600, res.TimeRecord.Time);
Assert.Equal(1304, res.TimeRecord.User);
Assert.Equal(new DateTime(2018, 1, 20), res.TimeRecord.Date);
Assert.Equal("ev:9876543210", res.TimeRecord.Task.Id);
Assert.Equal("Task Name", res.TimeRecord.Task.Name);
Assert.Equal(new List <string>()
{
"ev:1234567890"
}, res.TimeRecord.Task.Projects);
Assert.Equal(1234, res.TimeRecord.Task.Section);
Assert.Equal(new List <string>()
{
"high", "bug"
}, res.TimeRecord.Task.Labels);
Assert.Equal(1, res.TimeRecord.Task.Position);
Assert.Equal("description", res.TimeRecord.Task.Description);
Assert.Equal(new DateTime(2018, 3, 5, 16, 0, 0), res.TimeRecord.Task.DueAt);
Assert.Equal(Models.TaskStatus.OPEN, res.TimeRecord.Task.Status);
Assert.Equal(7200, res.TimeRecord.Task.Time.Total);
Assert.Equal(1304, res.TimeRecord.Task.Time.Users[0].Id);
Assert.Equal(3600, res.TimeRecord.Task.Time.Users[0].Time);
Assert.Equal(1543, res.TimeRecord.Task.Time.Users[1].Id);
Assert.Equal(3600, res.TimeRecord.Task.Time.Users[1].Time);
Assert.Equal(7200, res.TimeRecord.Task.Estimate.Total);
Assert.Equal(Models.EstimateType.OVERALL, res.TimeRecord.Task.Estimate.Type);
Assert.Equal(1304, res.TimeRecord.Task.Estimate.Users[0].Id);
Assert.Equal(3600, res.TimeRecord.Task.Estimate.Users[0].Time);
Assert.Equal(1543, res.TimeRecord.Task.Estimate.Users[1].Id);
Assert.Equal(3600, res.TimeRecord.Task.Estimate.Users[1].Time);
Assert.Equal("Everhour", res.TimeRecord.Task.Attributes[0].Client);
Assert.Equal("hight", res.TimeRecord.Task.Attributes[0].Priority);
Assert.Equal(42, res.TimeRecord.Task.Metrics[0].Efforts);
Assert.Equal(199, res.TimeRecord.Task.Metrics[0].Expenses);
Assert.True(res.TimeRecord.IsLocked);
Assert.True(res.TimeRecord.IsInvoiced);
Assert.Equal("some notes", res.TimeRecord.Comment);
}
public void AddTerm_AddingDuplicateWithCacheEnabled_DoesNotThrow()
{
var termCache = new List <string>();
termCache.Add("hello");
MockApi.Setup(x => x.GetAllTermsInTermListAsStringsAsync(sut.ListID.ToString(), sut.Language))
.Returns(Task.FromResult(termCache));
sut.EnableTermCache();
sut.AddTerm("hello").Wait();
}
public async Task StartTimerAsyncWithRequest_ReturnsTimer()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(Specification.START_TIMER)
}));
var req = new Models.StartTimerRequest()
{
TaskId = "ev:1234567890",
UserDate = DateTime.UtcNow,
Comment = "comment"
};
var res = await MockApi.Object.StartTimerAsync(req);
Assert.NotNull(res);
Assert.Equal(Models.TimerStatus.ACTIVE, res.Timer.Status);
Assert.Equal(16, res.Timer.Duration);
Assert.Equal(7200, res.Timer.Today);
Assert.Equal(new DateTime(2018, 01, 16, 12, 42, 59), res.Timer.StartedAt);
Assert.Equal(new DateTime(2018, 01, 16), res.Timer.UserDate);
Assert.Equal("comment", res.Timer.Comment);
Assert.Equal(1234, res.Timer.Task.Section);
Assert.Equal(new List <string>()
{
"high", "bug"
}, res.Timer.Task.Labels);
Assert.Equal(1, res.Timer.Task.Position);
Assert.Equal("description", res.Timer.Task.Description);
Assert.Equal(new DateTime(2018, 3, 5, 16, 0, 0), res.Timer.Task.DueAt);
Assert.Equal(Models.TaskStatus.OPEN, res.Timer.Task.Status);
Assert.Equal(7200, res.Timer.Task.Time.Total);
Assert.Equal(1304, res.Timer.Task.Time.Users[0].Id);
Assert.Equal(3600, res.Timer.Task.Time.Users[0].Time);
Assert.Equal(1543, res.Timer.Task.Time.Users[1].Id);
Assert.Equal(3600, res.Timer.Task.Time.Users[1].Time);
Assert.Equal(7200, res.Timer.Task.Estimate.Total);
Assert.Equal(Models.EstimateType.OVERALL, res.Timer.Task.Estimate.Type);
Assert.Equal(1304, res.Timer.Task.Estimate.Users[0].Id);
Assert.Equal(3600, res.Timer.Task.Estimate.Users[0].Time);
Assert.Equal(1543, res.Timer.Task.Estimate.Users[1].Id);
Assert.Equal(3600, res.Timer.Task.Estimate.Users[1].Time);
Assert.Equal("Everhour", res.Timer.Task.Attributes[0].Client);
Assert.Equal("hight", res.Timer.Task.Attributes[0].Priority);
Assert.Equal(42, res.Timer.Task.Metrics[0].Efforts);
Assert.Equal(199, res.Timer.Task.Metrics[0].Expenses);
Assert.Equal(1304, res.Timer.User.Id);
Assert.Equal("User Name", res.Timer.User.Name);
Assert.Equal("CEO", res.Timer.User.Headline);
Assert.Equal(Models.RoleType.ADMIN, res.Timer.User.Role);
Assert.Equal(Models.UserStatus.ACTIVE, res.Timer.User.Status);
}
public async Task ListTeamTimeRecordsAsyncWithFromTo_ReturnsTimeRecord()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.LIST_TEAM_TIME_RECORDS)));
var res = await MockApi.Object.ListTeamTimeRecordsAsync(DateTime.UtcNow, DateTime.UtcNow);
Assert.NotNull(res);
Assert.All(res.TeamTimeRecords, t => Assert.Equal(2660155, t.Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1304, t.User));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(new DateTime(2018, 1, 20), t.Date));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("ev:9876543210", t.Task.Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("Task Name", t.Task.Name));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(new List <string>()
{
"ev:1234567890"
}, t.Task.Projects));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1234, t.Task.Section));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(new List <string>()
{
"high", "bug"
}, t.Task.Labels));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1, t.Task.Position));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("description", t.Task.Description));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(new DateTime(2018, 3, 5, 16, 0, 0), t.Task.DueAt));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(Models.TaskStatus.OPEN, t.Task.Status));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(7200, t.Task.Time.Total));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1304, t.Task.Time.Users[0].Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.Task.Time.Users[0].Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1543, t.Task.Time.Users[1].Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.Task.Time.Users[1].Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(7200, t.Task.Estimate.Total));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(Models.EstimateType.OVERALL, t.Task.Estimate.Type));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1304, t.Task.Estimate.Users[0].Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.Task.Estimate.Users[0].Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1543, t.Task.Estimate.Users[1].Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.Task.Estimate.Users[1].Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("Everhour", t.Task.Attributes[0].Client));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("hight", t.Task.Attributes[0].Priority));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(42, t.Task.Metrics[0].Efforts));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(199, t.Task.Metrics[0].Expenses));
Assert.All(res.TeamTimeRecords, t => Assert.True(t.IsLocked));
Assert.All(res.TeamTimeRecords, t => Assert.True(t.IsInvoiced));
Assert.All(res.TeamTimeRecords, t => Assert.Equal("some notes", t.Comment));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(4622379, t.History[0].Id));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(1304, t.History[0].CreatedBy));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(3600, t.History[0].Time));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(0, t.History[0].PreviousTime));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(Models.HistoryStatus.TIMER, t.History[0].Status));
Assert.All(res.TeamTimeRecords, t => Assert.Equal(new DateTime(2018, 1, 16, 12, 42, 59), t.History[0].CreatedAt));
}
public async Task UpdateSectionAsync_ReturnsSection()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.UPDATE_SECTION)));
var res = await MockApi.Object.UpdateSectionAsync(1234, "Test Section");
Assert.NotNull(res);
Assert.NotEqual(default(int), res.Section.Id);
Assert.NotNull(res.Section.Name);
Assert.NotEqual(default(int), res.Section.Position);
Assert.NotNull(res.Section.Project);
Assert.Equal(Models.SectionStatus.OPEN, res.Section.Status);
}
public async Task ListProjectSectionsAsync_ReturnsSections()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.LIST_PROJECT_SECTIONS)));
var res = await MockApi.Object.ListProjectSectionsAsync("ev:1234567890");
Assert.NotNull(res);
Assert.All(res.Sections, s => Assert.NotEqual(default(int), s.Id));
Assert.All(res.Sections, s => Assert.NotNull(s.Name));
Assert.All(res.Sections, s => Assert.NotEqual(default(int), s.Position));
Assert.All(res.Sections, s => Assert.NotNull(s.Project));
Assert.All(res.Sections, s => Assert.Equal(Models.SectionStatus.OPEN, s.Status));
}
public async Task MeAsync_ReturnsUser()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(Specification.ME)
}));
var res = await MockApi.Object.MeAsync();
Assert.NotNull(res);
Assert.NotEqual(default(int), res.Me.Id);
Assert.Equal(Models.RoleType.ADMIN, res.Me.Role);
Assert.Equal(Models.UserStatus.ACTIVE, res.Me.Status);
}
public void AddTerm_AddingDuplicateWithCacheDisabled_Throws()
{
var termCache = new List <string>();
var term = "hello";
termCache.Add(term);
MockApi.Setup(x => x.GetAllTermsInTermListAsStringsAsync(sut.ListID.ToString(), sut.Language))
.Returns(Task.FromResult(termCache));
MockApi.Setup(x => x.AddTermToTermListAsync(sut.ListID.ToString(), term, sut.Language))
.Throws <Exception>();
sut.DisableTermCache();
Assert.Throws <AggregateException>(() => sut.AddTerm("hello").Wait());
}
public async Task CreateClientAsync_ReturnsClient()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.CREATE_CLIENT)));
var res = await MockApi.Object.CreateClientAsync("Test Cleint");
Assert.NotNull(res);
Assert.NotEqual(default(int), res.Client.Id);
Assert.NotNull(res.Client.Name);
Assert.NotNull(res.Client.Projects);
Assert.NotNull(res.Client.BusinessDetails);
Assert.NotEqual(default(int), res.Client.Budget.Value);
Assert.NotEqual(default(int), res.Client.Budget.Progress);
Assert.Equal(Models.BudgetType.MONEY, res.Client.Budget.Type);
}
public async Task ListAllClientsAsync_ReturnsClients()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.LIST_CLIENTS)));
var res = await MockApi.Object.ListAllClientsAsync();
Assert.NotNull(res);
Assert.All(res.Clients, c => Assert.NotEqual(default(int), c.Id));
Assert.All(res.Clients, c => Assert.NotNull(c.Name));
Assert.All(res.Clients, c => Assert.NotNull(c.Projects));
Assert.All(res.Clients, c => Assert.NotNull(c.BusinessDetails));
Assert.All(res.Clients, c => Assert.NotEqual(default(int), c.Budget.Value));
Assert.All(res.Clients, c => Assert.NotEqual(default(int), c.Budget.Progress));
Assert.All(res.Clients, c => Assert.Equal(Models.BudgetType.MONEY, c.Budget.Type));
}
public async Task It_returns_result_parsed_from_error_JSON()
{
// Arrange
// Copied from real life error
string jsonError = "{\"Result\":\"Failure\",\"Message\":\"Invalid Launch Code\"}";
MockApi.WarheadsLaunchAsync(null)
.ThrowsForAnyArgs(new ApiException(500, null, jsonError));
// Act
var actual = await SUT.Launch(CorrectPassphrase);
// Assert
actual.Message.Should().Be("Invalid Launch Code");
}
public async Task It_returns_false()
{
// Arrange
MockApi.WarheadsGetStatusAsync()
.Returns(Task.FromResult(new WarheadStatusResult
{
Status = Online
}));
// Act
var actual = await SUT.IsOffline();
// Assert
actual.Should().BeFalse();
}
public async Task ListTeamUsersTimersAsync_ReturnsTimers()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(Specification.LIST_TEAM_USERS_TIMERS)
}));
var res = await MockApi.Object.ListTeamUsersTimersAsync();
Assert.NotNull(res);
Assert.All(res.Timers, e => Assert.Equal(Models.TimerStatus.ACTIVE, e.Status));
Assert.All(res.Timers, e => Assert.Equal(16, e.Duration));
Assert.All(res.Timers, e => Assert.Equal(7200, e.Today));
Assert.All(res.Timers, e => Assert.Equal(new DateTime(2018, 01, 16, 12, 42, 59), e.StartedAt));
Assert.All(res.Timers, e => Assert.Equal(new DateTime(2018, 01, 16), e.UserDate));
Assert.All(res.Timers, e => Assert.Equal("comment", e.Comment));
Assert.All(res.Timers, e => Assert.Equal(1234, e.Task.Section));
Assert.All(res.Timers, e => Assert.Equal(new List <string>()
{
"high", "bug"
}, e.Task.Labels));
Assert.All(res.Timers, e => Assert.Equal(1, e.Task.Position));
Assert.All(res.Timers, e => Assert.Equal("description", e.Task.Description));
Assert.All(res.Timers, e => Assert.Equal(new DateTime(2018, 3, 5, 16, 0, 0), e.Task.DueAt));
Assert.All(res.Timers, e => Assert.Equal(Models.TaskStatus.OPEN, e.Task.Status));
Assert.All(res.Timers, e => Assert.Equal(7200, e.Task.Time.Total));
Assert.All(res.Timers, e => Assert.Equal(1304, e.Task.Time.Users[0].Id));
Assert.All(res.Timers, e => Assert.Equal(3600, e.Task.Time.Users[0].Time));
Assert.All(res.Timers, e => Assert.Equal(1543, e.Task.Time.Users[1].Id));
Assert.All(res.Timers, e => Assert.Equal(3600, e.Task.Time.Users[1].Time));
Assert.All(res.Timers, e => Assert.Equal(7200, e.Task.Estimate.Total));
Assert.All(res.Timers, e => Assert.Equal(Models.EstimateType.OVERALL, e.Task.Estimate.Type));
Assert.All(res.Timers, e => Assert.Equal(1304, e.Task.Estimate.Users[0].Id));
Assert.All(res.Timers, e => Assert.Equal(3600, e.Task.Estimate.Users[0].Time));
Assert.All(res.Timers, e => Assert.Equal(1543, e.Task.Estimate.Users[1].Id));
Assert.All(res.Timers, e => Assert.Equal(3600, e.Task.Estimate.Users[1].Time));
Assert.All(res.Timers, e => Assert.Equal("Everhour", e.Task.Attributes[0].Client));
Assert.All(res.Timers, e => Assert.Equal("hight", e.Task.Attributes[0].Priority));
Assert.All(res.Timers, e => Assert.Equal(42, e.Task.Metrics[0].Efforts));
Assert.All(res.Timers, e => Assert.Equal(199, e.Task.Metrics[0].Expenses));
Assert.All(res.Timers, e => Assert.Equal(1304, e.User.Id));
Assert.All(res.Timers, e => Assert.Equal("User Name", e.User.Name));
Assert.All(res.Timers, e => Assert.Equal("CEO", e.User.Headline));
Assert.All(res.Timers, e => Assert.Equal(Models.RoleType.ADMIN, e.User.Role));
Assert.All(res.Timers, e => Assert.Equal(Models.UserStatus.ACTIVE, e.User.Status));
}
public async Task TestAsync(string name, string extention)
{
var baseFile = new FileInfo($"./Resources/{name}{extention}");
var testFileName = Path.Combine(Path.GetTempPath(), Path.GetTempFileName() + extention);
baseFile.CopyTo(testFileName, true);
var testFile = new FileInfo(testFileName);
FileInfo uploadedFile = null;
try
{
var expectedId = Id.Create(Guid.NewGuid());
var api = new MockApi(new MediaFile {
Id = expectedId
});
var example = new MediaFileExample(api);
await example.Run(testFile);
uploadedFile = new FileInfo(Path.Combine(api.TempFileLocation, testFile.Name));
Assert.True(uploadedFile.Exists);
var mediaFile = api.MediaFile;
var size = JObject.Parse(mediaFile.MetaData)["size"];
Assert.Equal(expectedId, mediaFile.Id);
Assert.Equal(uploadedFile.Length, size);
// example only resizes images
if (mediaFile.MediaType != MediaType.Video)
{
Assert.NotEqual(testFile.Length, size);
}
File.Delete(uploadedFile.FullName);
}
finally
{
File.Delete(testFile.FullName);
if (uploadedFile != null)
{
File.Delete(uploadedFile.FullName);
}
}
}
public void Given()
{
const string username = "******";
const string password = "******";
_recipient = "44123456789";
_surveyId = Guid.NewGuid();
_expectedUrl = string.Format("/v1.0/surveys/{0}/send", _surveyId);
_expectedUserAgent = string.Format("Esendex .NET SDK v{0}.{1}.{2}", _version.Major, _version.Minor, _version.Build);
MockApi.SetEndpoint(new MockEndpoint(200, contentType: "text/plain"));
var surveysClient = new SurveysService(MockApi.Url, new EsendexCredentials(username, password));
surveysClient.Send(_surveyId, _recipient);
_request = MockApi.LastRequest;
}
public async Task ExportAllTeamEstimatesAsync_ReturnsTeamEstimates()
{
MockApi.Setup(x => x.ExecuteAsync(It.IsAny <HttpRequestMessage>()))
.Returns(Task.FromResult(GenerateMockResponse(Specification.EXPORT_ESITIMATES)));
var res = await MockApi.Object.ExportAllTeamEstimatesAsync();
Assert.NotNull(res);
Assert.All(res.TeamEstimates, e => Assert.NotEqual(default(int), e.Time.Total));
Assert.All(res.TeamEstimates, e => Assert.NotEqual(default(int), e.Estimate.Total));
Assert.All(res.TeamEstimates, e => Assert.Equal(Models.EstimateType.OVERALL, e.Estimate.Type));
Assert.All(res.TeamEstimates, e => Assert.NotNull(e.Project.Id));
Assert.All(res.TeamEstimates, e => Assert.NotNull(e.Project.Name));
Assert.All(res.TeamEstimates, e => Assert.NotNull(e.Project.Workspace));
Assert.All(res.TeamEstimates, e => Assert.NotNull(e.Task.Id));
Assert.All(res.TeamEstimates, e => Assert.NotNull(e.Task.Name));
Assert.All(res.TeamEstimates, e => Assert.Equal(Models.TaskType.TASK, e.Task.Type));
}
public void Given()
{
const string username = "******";
const string password = "******";
MockApi.SetEndpoint(new MockEndpoint(_statusCode));
var optOutClient = new OptOutsService(MockApi.Url, new EsendexCredentials(username, password));
try
{
optOutClient.Add("something", "somethingelse");
}
catch (WebException ex)
{
_result = ex;
}
}
