public async Task GetApiLinksNotPermitted()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.ValidAccessToken_InvalidService).Build();
this.Fixture.AdPostingApiService
.UponReceiving("a GET index request that is unauthorised to retrieve API links")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/",
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + AccessTokens.ValidAccessToken_InvalidService },
{ "Accept", $"{ResponseContentTypes.Hal}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = (int)HttpStatusCode.Unauthorized,
Headers = new Dictionary<string, string> { { "X-Request-Id", RequestId } }
});
UnauthorizedException actualException;
using (var client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.InitialiseIndexResource(this.Fixture.AdPostingApiServiceBaseUri));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(RequestId, 401, $"[GET] {this.Fixture.AdPostingApiServiceBaseUri} is not authorized."));
}
public async Task GetAllAdvertisementsWithNoAdvertisementsReturned()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.Given("There are no advertisements")
.UponReceiving("a GET advertisements request for all advertisements")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/advertisement",
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementListVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementListVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
_embedded = new { advertisements = new AdvertisementSummary[] { } },
_links = new { self = new { href = "/advertisement" } }
}
});
AdvertisementSummaryPageResource advertisements;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
advertisements = await client.GetAllAdvertisementsAsync();
}
AdvertisementSummaryPageResource expectedAdvertisements = new AdvertisementSummaryPageResource
{
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri) { { "self", new Link { Href = "/advertisement" } } },
AdvertisementSummaries = new List<AdvertisementSummaryResource>(),
RequestId = RequestId
};
advertisements.ShouldBeEquivalentTo(expectedAdvertisements);
}
public async Task GetExistingAdvertisementStatusUsingHalSelfLink()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.SetupPactForGettingExistingAdvertisementStatus(link, oAuth2Token);
ProcessingStatus status;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
status = await client.GetAdvertisementStatusAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
}
Assert.Equal(ProcessingStatus.Pending, status);
}
public async Task ExpireAdvertisementUsingHalSelfLink()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
string link = $"{AdvertisementLink}/{advertisementId}";
string viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
DateTime expiryDate = new DateTime(2015, 10, 7, 21, 19, 00, DateTimeKind.Utc);
this.SetupPactForExpiringExistingAdvertisement(link, oAuth2Token, advertisementId, viewRenderedAdvertisementLink, expiryDate);
AdvertisementResource result;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
result = await client.ExpireAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
}
this.AssertReturnedAdvertisementMatchesExpectedExpiredAdvertisement(advertisementId, expiryDate, result);
}
public async Task GetExistingAdvertisementStatusUsingHalTemplateWithAdvertisementId()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.SetupPactForGettingExistingAdvertisementStatus(link, oAuth2Token);
ProcessingStatus status;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
status = await client.GetAdvertisementStatusAsync(new Guid(advertisementId));
}
Assert.Equal(ProcessingStatus.Pending, status);
}
public async Task GetExistingAdvertisementUsingHalSelfLink(LocationType locationType, string givenStatement)
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
var viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
var builderInitializer = new AllFieldsInitializer(locationType);
this.SetupPactForGettingExistingAdvertisement(givenStatement, link, oAuth2Token, builderInitializer, advertisementId, viewRenderedAdvertisementLink);
AdvertisementResource result;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
result = await client.GetAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
}
this.AssertRetrievedAdvertisementMatchesExpected(builderInitializer, advertisementId, result);
}
public async Task PostAdWithInvalidFieldValues()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job ad with invalid field values")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId("20150914-134527-00109")
.WithAdvertisementType(AdvertisementType.StandOut.ToString())
.WithSalaryMinimum(-1.0)
.WithStandoutBullets("new Uzi", "new Remington Model".PadRight(85, '!'), "new AK-47")
.WithApplicationEmail("someone(at)some.domain")
.WithApplicationFormUrl("htp://somecompany.domain/apply")
.WithTemplateItems(
new KeyValuePair<object, object>("Template Line 1", "Template Value 1"),
new KeyValuePair<object, object>("", "value2"))
.Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 422,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Validation Failure",
errors = new[]
{
new { field = "applicationEmail", code = "InvalidEmailAddress" },
new { field = "applicationFormUrl", code = "InvalidUrl" },
new { field = "salary.minimum", code = "ValueOutOfRange" },
new { field = "standout.bullets[1]", code = "MaxLengthExceeded" },
new { field = "template.items[1].name", code = "Required" }
}
}
});
ValidationException exception;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
exception = await Assert.ThrowsAsync<ValidationException>(
async () =>
await client.CreateAdvertisementAsync(new AdvertisementModelBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId("20150914-134527-00109")
.WithAdvertisementType(AdvertisementType.StandOut)
.WithSalaryMinimum(-1)
.WithStandoutBullets("new Uzi", "new Remington Model".PadRight(85, '!'), "new AK-47")
.WithApplicationEmail("someone(at)some.domain")
.WithApplicationFormUrl("htp://somecompany.domain/apply")
.WithTemplateItems(
new TemplateItem { Name = "Template Line 1", Value = "Template Value 1" },
new TemplateItem { Name = "", Value = "value2" })
.Build()));
}
var expectedException =
new ValidationException(
RequestId,
HttpMethod.Post,
new AdvertisementErrorResponse
{
Message = "Validation Failure",
Errors = new[]
{
new AdvertisementError { Field = "applicationEmail", Code = "InvalidEmailAddress" },
new AdvertisementError { Field = "applicationFormUrl", Code = "InvalidUrl" },
new AdvertisementError { Field = "salary.minimum", Code = "ValueOutOfRange" },
new AdvertisementError { Field = "standout.bullets[1]", Code = "MaxLengthExceeded" },
new AdvertisementError { Field = "template.items[1].name", Code = "Required" }
}
});
exception.ShouldBeEquivalentToException(expectedException);
}
public async Task ExpireAdvertisementUsingInvalidRequestContent()
{
var advertisementId = new Guid("8e2fde50-bc5f-4a12-9cfb-812e50500184");
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.OtherThirdPartyUploader).Build();
var link = $"{AdvertisementLink}/{advertisementId}";
var acceptHeader = this._acceptHeader;
var requestBody = new[]
{
new
{
op = "add",
path = "state",
value = "open"
}
};
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a PATCH advertisement request to expire a job using invalid request content")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Patch,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementPatchVersion1 },
{ "Accept", acceptHeader },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = requestBody
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 422,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Validation Failure",
errors = new[] { new { code = "InvalidRequestContent" } }
}
});
using (var client = new HttpClient())
{
using (HttpRequestMessage request = this.CreatePatchRequest(
new Uri(this.Fixture.AdPostingApiServiceBaseUri, link), requestBody, AccessTokens.OtherThirdPartyUploader))
{
using (HttpResponseMessage response = await client.SendAsync(request))
{
Assert.Equal(422, (int)response.StatusCode);
}
}
}
}
public async Task GetAllAdvertisementsByAdvertiserNextPage()
{
const string advertiserId = "456";
const string advertisementId1 = "f7302df2-704b-407c-a42a-62ff822b5461";
const string beforeJobId = "5";
const string queryString = "advertiserId=" + advertiserId + "&beforeId=" + beforeJobId;
const string selfLink = "/advertisement?" + queryString;
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.AdPostingApiService
.Given("A page size of 3 with more than 1 page of data")
.UponReceiving("a GET advertisements request for the second page of advertisements belonging to the advertiser")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/advertisement",
Query = queryString,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementListVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementListVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
_embedded = new
{
advertisements = new[]
{
new AdvertisementSummaryResponseContentBuilder()
.WithId(advertisementId1)
.WithAdvertiserId(advertiserId)
.WithJobTitle("Exciting Developer role in a great CBD location. Great $$")
.WithJobReference("JOB1111")
.WithResponseLink("self", this.GenerateSelfLink(advertisementId1))
.WithResponseLink("view", this.GenerateViewLink(advertisementId1))
.Build()
}
},
_links = new
{
self = new { href = selfLink }
}
}
});
AdvertisementSummaryPageResource pageResource = new AdvertisementSummaryPageResource
{
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{"self", new Link {Href = "/advertisement"}},
{"next", new Link {Href = $"/advertisement?advertiserId={advertiserId}&beforeId={beforeJobId}"}}
}
};
var oAuthClient = Mock.Of<IOAuth2TokenClient>(c => c.GetOAuth2TokenAsync() == Task.FromResult(oAuth2Token));
AdvertisementSummaryPageResource nextPageResource;
using (var client = new Hal.Client(new HttpClient(new AdPostingApiMessageHandler(new OAuthMessageHandler(oAuthClient)))))
{
pageResource.Initialise(client);
nextPageResource = await pageResource.NextPageAsync();
}
AdvertisementSummaryPageResource expectedNextPageResource = new AdvertisementSummaryPageResource
{
AdvertisementSummaries = new List<AdvertisementSummaryResource>
{
new AdvertisementSummaryResource
{
Id = new Guid(advertisementId1),
AdvertiserId = advertiserId,
JobReference = "JOB1111",
JobTitle = "Exciting Developer role in a great CBD location. Great $$",
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{"self", new Link {Href = $"/advertisement/{advertisementId1}"}},
{"view", new Link {Href = $"/advertisement/{advertisementId1}/view"}}
}
}
},
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{"self", new Link {Href = selfLink}}
},
RequestId = RequestId
};
nextPageResource.ShouldBeEquivalentTo(expectedNextPageResource);
}
public async Task ExpireAdvertisementWhereAdvertiserNotRelatedToRequestor()
{
var advertisementId = new Guid("8e2fde50-bc5f-4a12-9cfb-812e50500184");
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.OtherThirdPartyUploader).Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a PATCH advertisement request to expire a job for an advertiser not related to the requestor's account")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Patch,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementPatchVersion1 },
{ "Accept", this._acceptHeader },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new[]
{
new
{
op = "replace",
path = "state",
value = AdvertisementState.Expired.ToString()
}
}
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "RelationshipError" } }
}
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.ExpireAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "RelationshipError" } }
}));
}
public async Task ExpireNonExistentAdvertisment()
{
var advertisementId = new Guid("9b650105-7434-473f-8293-4e23b7e0e064");
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.UponReceiving("a PATCH advertisement request to expire a non-existent advertisement")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Patch,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementPatchVersion1 },
{ "Accept", this._acceptHeader },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new[]
{
new
{
op = "replace",
path = "state",
value = AdvertisementState.Expired.ToString()
}
}
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 404,
Headers = new Dictionary<string, string> { { "X-Request-Id", RequestId } }
});
AdvertisementNotFoundException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<AdvertisementNotFoundException>(
async () => await client.ExpireAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
actualException.ShouldBeEquivalentToException(new AdvertisementNotFoundException(RequestId));
}
public async Task GetExistingAdvertisementWithWarnings()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
var viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a GET advertisement request for an advertisement with warnings")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementVersion1 },
{ "Processing-Status", "Pending" },
{ "X-Request-Id", RequestId }
},
Body = new AdvertisementResponseContentBuilder(AllFieldsInitializer)
.WithId(advertisementId)
.WithState(AdvertisementState.Open.ToString())
.WithLink("self", link)
.WithLink("view", viewRenderedAdvertisementLink)
.WithWarnings(
new { field = "standout.logoId", code = "missing" },
new { field = "standout.bullets", code = "missing" })
.WithAgentId(null)
.WithAdditionalProperties(AdditionalPropertyType.ResidentsOnly.ToString(), AdditionalPropertyType.Graduate.ToString())
.Build()
});
AdvertisementResource result;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
result = await client.GetAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
}
AdvertisementResource expectedResult = new AdvertisementResourceBuilder(this.AllFieldsInitializer)
.WithId(new Guid(advertisementId))
.WithLinks(advertisementId)
.WithProcessingStatus(ProcessingStatus.Pending)
.WithWarnings(
new AdvertisementError { Field = "standout.logoId", Code = "missing" },
new AdvertisementError { Field = "standout.bullets", Code = "missing" })
.WithAgentId(null)
.Build();
result.ShouldBeEquivalentTo(expectedResult);
}
public async Task PostAdWithExistingCreationId()
{
const string creationId = "CreationIdOf8e2fde50-bc5f-4a12-9cfb-812e50500184";
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var location = $"http://localhost{AdvertisementLink}/{advertisementId}";
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving($"a POST advertisement request to create a job ad with the same creation id '{creationId}'")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer).WithRequestCreationId(creationId).Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 409,
Headers = new Dictionary<string, string>
{
{ "Location", location },
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Conflict",
errors = new[] { new { field = "creationId", code = "AlreadyExists" } }
}
});
CreationIdAlreadyExistsException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<CreationIdAlreadyExistsException>(
async () => await client.CreateAdvertisementAsync(new AdvertisementModelBuilder(this.MinimumFieldsInitializer).WithRequestCreationId(creationId).Build()));
}
var expectedException = new CreationIdAlreadyExistsException(RequestId, new Uri(location),
new AdvertisementErrorResponse
{
Message = "Conflict",
Errors = new[] { new AdvertisementError { Field = "creationId", Code = "AlreadyExists" } }
});
actualException.ShouldBeEquivalentToException(expectedException);
}
public async Task GetAllAdvertisementByAdvertiserWithNonExistentAdvertiserId()
{
string advertiser = "7d31d9b4-d922-43ef-9e88-f7b507ceea88";
string queryString = "advertiserId=" + advertiser;
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a GET advertisements request to retrieve all advertisements for an advertiser that doesn't exist")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/advertisement",
Query = queryString,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementListVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "InvalidValue" } }
}
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(async () => await client.GetAllAdvertisementsAsync(advertiser));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "InvalidValue" } }
}));
}
public async Task PostAdWithDuplicateTemplateCustomFieldNames()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job ad with duplicated names for template custom fields")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId(CreationIdForAdWithDuplicateTemplateCustomFields)
.WithTemplateItems(
new KeyValuePair<object, object>("FieldNameA", "Template Value 1"),
new KeyValuePair<object, object>("FieldNameB", "Template Value 2"),
new KeyValuePair<object, object>("FieldNameA", "Template Value 3"))
.Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 422,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Validation Failure",
errors = new[]
{
new { field = "template.items[0]", code = "AlreadySpecified" },
new { field = "template.items[2]", code = "AlreadySpecified" }
}
}
});
ValidationException exception;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
exception = await Assert.ThrowsAsync<ValidationException>(
async () =>
await client.CreateAdvertisementAsync(new AdvertisementModelBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId(CreationIdForAdWithDuplicateTemplateCustomFields)
.WithTemplateItems(
new TemplateItem { Name = "FieldNameA", Value = "Template Value 1" },
new TemplateItem { Name = "FieldNameB", Value = "Template Value 2" },
new TemplateItem { Name = "FieldNameA", Value = "Template Value 3" })
.Build()));
}
var expectedException = new ValidationException(
RequestId,
HttpMethod.Post,
new AdvertisementErrorResponse
{
Message = "Validation Failure",
Errors = new[]
{
new AdvertisementError { Field = "template.items[0]", Code = "AlreadySpecified" },
new AdvertisementError { Field = "template.items[2]", Code = "AlreadySpecified" }
}
});
exception.ShouldBeEquivalentToException(expectedException);
}
public async Task GetAllAdvertisementsByAdvertiserReturnsRelationshipError()
{
var advertiserId = "874392";
string queryString = "advertiserId=" + advertiserId;
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.OtherThirdPartyUploader).Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a GET advertisements request to retrieve all advertisements for the advertiser not related to requestor")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/advertisement",
Query = queryString,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementListVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "RelationshipError" } }
}
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(async () => await client.GetAllAdvertisementsAsync(advertiserId));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "RelationshipError" } }
}));
}
public async Task GetAdvertisementStatusWhereAdvertiserNotRelatedToRequestor()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.OtherThirdPartyUploader).Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a HEAD advertisement request for an advertisement of an advertiser not related to the requestor's account")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Head,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(
new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string> { { "X-Request-Id", RequestId } }
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.GetAdvertisementStatusAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
$"[HEAD] {this.Fixture.AdPostingApiServiceBaseUri}advertisement/{advertisementId} is not authorized."));
}
public async Task GetAdvertisementUsingDisabledRequestorAccount()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().WithAccessToken(AccessTokens.ValidAccessToken_Disabled).Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a GET advertisement request for an advertisement using a disabled requestor account")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "AccountError" } }
}
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.GetAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "AccountError" } }
}));
}
public async Task GetExistingAdvertisementWithErrors()
{
const string advertisementId = "448b8474-6165-4eed-a5b5-d2bb52e471ef";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
var viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
this.Fixture.AdPostingApiService
.Given("There is a failed classic advertisement")
.UponReceiving("a GET advertisement request for an advertisement with errors")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementVersion1 },
{ "Processing-Status", "Failed" },
{ "X-Request-Id", RequestId }
},
Body = new AdvertisementResponseContentBuilder(this.MinimumFieldsInitializer)
.WithId(advertisementId)
.WithState(AdvertisementState.Open.ToString())
.WithLink("self", link)
.WithLink("view", viewRenderedAdvertisementLink)
.WithErrors(new { code = "Unauthorised", message = "Unauthorised" })
.WithAgentId(null)
.Build()
});
AdvertisementResource result;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
result = await client.GetAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link));
}
AdvertisementResource expectedResult = new AdvertisementResourceBuilder(this.MinimumFieldsInitializer)
.WithId(new Guid(advertisementId))
.WithLinks(advertisementId)
.WithProcessingStatus(ProcessingStatus.Failed)
.WithErrors(new AdvertisementError { Code = "Unauthorised", Message = "Unauthorised" })
.WithAgentId(null)
.Build();
result.ShouldBeEquivalentTo(expectedResult);
}
public async Task PostAdWithInvalidAdvertisementDetails()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job ad with invalid advertisement details")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId("20150914-134527-00109")
.WithAdvertisementDetails("Ad details with <a href='www.youtube.com'>a link</a> and incomplete <h2> element")
.Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 422,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Validation Failure",
errors = new[]
{
new { field = "advertisementDetails", code = "InvalidFormat" }
}
}
});
ValidationException exception;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
exception = await Assert.ThrowsAsync<ValidationException>(
async () =>
await client.CreateAdvertisementAsync(new AdvertisementModelBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId("20150914-134527-00109")
.WithAdvertisementDetails("Ad details with <a href='www.youtube.com'>a link</a> and incomplete <h2> element")
.Build()));
}
var expectedException =
new ValidationException(
RequestId,
HttpMethod.Post,
new AdvertisementErrorResponse
{
Message = "Validation Failure",
Errors = new[] { new AdvertisementError { Field = "advertisementDetails", Code = "InvalidFormat" } }
});
exception.ShouldBeEquivalentToException(expectedException);
}
public async Task ExpireAdvertisementWithPostVerb()
{
const string advertisementId = "8e2fde50-bc5f-4a12-9cfb-812e50500184";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
string link = $"{AdvertisementLink}/{advertisementId}";
string viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
DateTime expiryDate = new DateTime(2015, 10, 7, 21, 19, 00, DateTimeKind.Utc);
this.Fixture.AdPostingApiService
.Given("There is a pending standout advertisement with maximum data")
.UponReceiving("a POST advertisement request to expire an advertisement")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementPatchVersion1 },
{ "Accept", this._acceptHeader },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = this._expireRequest
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 202,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new AdvertisementResponseContentBuilder(this.AllFieldsInitializer)
.WithId(advertisementId)
.WithState(AdvertisementState.Expired.ToString())
.WithLink("self", link)
.WithLink("view", viewRenderedAdvertisementLink)
.WithExpiryDate(expiryDate)
.WithAgentId(null)
.WithAdditionalProperties(AdditionalPropertyType.ResidentsOnly.ToString(), AdditionalPropertyType.Graduate.ToString())
.Build()
});
AdvertisementResource result;
var requestUri = new Uri(this.Fixture.AdPostingApiServiceBaseUri, link);
using (var client = new HttpClient())
{
using (HttpRequestMessage request = this.CreatePatchRequest(requestUri, this._expireRequest, oAuth2Token.AccessToken, "POST"))
{
using (HttpResponseMessage response = await client.SendAsync(request))
{
response.EnsureSuccessStatusCode();
result = JsonConvert.DeserializeObject<AdvertisementResource>(
await response.Content.ReadAsStringAsync(), new ResourceConverter(null, requestUri, response.Headers));
}
}
}
AdvertisementResource expectedResult = new AdvertisementResourceBuilder(this.AllFieldsInitializer)
.WithId(new Guid(advertisementId))
.WithLinks(advertisementId)
.WithState(AdvertisementState.Expired)
.WithExpiryDate(expiryDate)
.WithAgentId(null)
.Build();
result.ShouldBeEquivalentTo(expectedResult);
}
public async Task PostAdWithNoCreationId()
{
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job ad without a creation id")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer).Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 422,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Validation Failure",
errors = new[]
{
new { field = "creationId", code = "Required" }
}
}
});
ValidationException exception;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
exception = await Assert.ThrowsAsync<ValidationException>(
async () => await client.CreateAdvertisementAsync(new AdvertisementModelBuilder(this.MinimumFieldsInitializer).Build()));
}
exception.ShouldBeEquivalentToException(
new ValidationException(
RequestId,
HttpMethod.Post,
new AdvertisementErrorResponse
{
Message = "Validation Failure",
Errors = new[] { new AdvertisementError { Field = "creationId", Code = "Required" } }
}));
}
public async Task ExpireAlreadyExpiredAdvertisement()
{
var advertisementId = new Guid("c294088d-ff50-4374-bc38-7fa805790e3e");
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.Given("There is an expired advertisement")
.UponReceiving("a PATCH advertisement request to expire an advertisement")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Patch,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementPatchVersion1 },
{ "Accept", this._acceptHeader },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new[]
{
new
{
op = "replace",
path = "state",
value = AdvertisementState.Expired.ToString()
}
}
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "Expired" } }
}
});
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.ExpireAdvertisementAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
var expectedException =
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "Expired" } }
});
actualException.ShouldBeEquivalentToException(expectedException);
}
public async Task PostAdWhereAdvertiserNotRelatedToRequestor()
{
var oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job for an advertiser not related to the requestor's account")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(this.MinimumFieldsInitializer)
.WithRequestCreationId(CreationIdForAdWithMinimumRequiredData)
.WithAdvertiserId("999888777")
.Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 403,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementErrorVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
message = "Forbidden",
errors = new[] { new { code = "RelationshipError" } }
}
});
var requestModel = new AdvertisementModelBuilder(this.MinimumFieldsInitializer).WithRequestCreationId(CreationIdForAdWithMinimumRequiredData).WithAdvertiserId("999888777").Build();
UnauthorizedException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<UnauthorizedException>(
async () => await client.CreateAdvertisementAsync(requestModel));
}
actualException.ShouldBeEquivalentToException(
new UnauthorizedException(
RequestId,
403,
new AdvertisementErrorResponse
{
Message = "Forbidden",
Errors = new[] { new AdvertisementError { Code = "RelationshipError" } }
}));
}
public async Task GetAllAdvertisementsFirstPage()
{
const string advertisementId3 = "9141cf19-b8d7-4380-9e3f-3b5c22783bdc";
const string advertisementId2 = "7bbe4318-fd3b-4d26-8384-d41489ff1dd0";
const string advertisementId1 = "e6e31b9c-3c2c-4b85-b17f-babbf7da972b";
const string advertisement3Title = "More Exciting Senior Developer role in a great CBD location. Great $$$";
const string advertisement2Title = "More Exciting Senior Tester role in a great CBD location. Great $$$";
const string advertisement1Title = "More Exciting Senior Developer role in a great CBD location. Great $$$";
const string advertisement3Reference = "JOB4444";
const string advertisement2Reference = "JOB3333";
const string advertisement1Reference = "JOB12345";
const string beforeJobId = "6";
const string nextLink = "/advertisement?beforeId=" + beforeJobId;
const string selfLink = "/advertisement";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
this.Fixture.AdPostingApiService
.Given("A page size of 3 with more than 1 page of data")
.UponReceiving("a GET advertisements request for first page of data")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Get,
Path = "/advertisement",
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementListVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 200,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementListVersion1 },
{ "X-Request-Id", RequestId }
},
Body = new
{
_embedded = new
{
advertisements = new[]
{
new AdvertisementSummaryResponseContentBuilder()
.WithId(advertisementId3)
.WithAdvertiserId("456")
.WithJobTitle(advertisement3Title)
.WithJobReference(advertisement3Reference)
.WithResponseLink("self", this.GenerateSelfLink(advertisementId3))
.WithResponseLink("view", this.GenerateViewLink(advertisementId3))
.Build(),
new AdvertisementSummaryResponseContentBuilder()
.WithId(advertisementId2)
.WithAdvertiserId("456")
.WithJobTitle(advertisement2Title)
.WithJobReference(advertisement2Reference)
.WithResponseLink("self", this.GenerateSelfLink(advertisementId2))
.WithResponseLink("view", this.GenerateViewLink(advertisementId2))
.Build(),
new AdvertisementSummaryResponseContentBuilder()
.WithId(advertisementId1)
.WithAdvertiserId("345")
.WithJobTitle(advertisement1Title)
.WithJobReference(advertisement1Reference)
.WithResponseLink("self", this.GenerateSelfLink(advertisementId1))
.WithResponseLink("view", this.GenerateViewLink(advertisementId1))
.Build()
}
},
_links = new
{
self = new { href = selfLink },
next = new { href = nextLink }
}
}
});
AdvertisementSummaryPageResource pageResource;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
pageResource = await client.GetAllAdvertisementsAsync();
}
AdvertisementSummaryPageResource expectedPageResource = new AdvertisementSummaryPageResource
{
AdvertisementSummaries = new List<AdvertisementSummaryResource>
{
new AdvertisementSummaryResource
{
Id = new Guid(advertisementId3),
AdvertiserId = "456",
JobReference = advertisement3Reference,
JobTitle = advertisement3Title,
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{ "self", new Link { Href = $"/advertisement/{advertisementId3}" } },
{ "view", new Link { Href = $"/advertisement/{advertisementId3}/view" } }
}
},
new AdvertisementSummaryResource
{
Id = new Guid(advertisementId2),
AdvertiserId = "456",
JobReference = advertisement2Reference,
JobTitle = advertisement2Title,
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{ "self", new Link { Href = $"/advertisement/{advertisementId2}" } },
{ "view", new Link { Href = $"/advertisement/{advertisementId2}/view" } }
}
},
new AdvertisementSummaryResource
{
Id = new Guid(advertisementId1),
AdvertiserId = "345",
JobReference = advertisement1Reference,
JobTitle = advertisement1Title,
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{ "self", new Link { Href = $"/advertisement/{advertisementId1}" } },
{ "view", new Link { Href = $"/advertisement/{advertisementId1}/view" } }
}
}
},
Links = new Links(this.Fixture.AdPostingApiServiceBaseUri)
{
{ "self", new Link { Href = "/advertisement" } },
{ "next", new Link { Href = "/advertisement?beforeId=" + beforeJobId} }
},
RequestId = RequestId
};
pageResource.ShouldBeEquivalentTo(expectedPageResource);
}
public async Task PostAdWithGranularLocation()
{
const string advertisementId = "75b2b1fc-9050-4f45-a632-ec6b7ac2bb4a";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
var viewRenderedAdvertisementLink = $"{AdvertisementLink}/{advertisementId}/view";
var location = $"http://localhost{link}";
this.Fixture.RegisterIndexPageInteractions(oAuth2Token);
var allFieldsWithGranularLocationInitializer = new AllFieldsInitializer(LocationType.UseGranularLocation);
this.Fixture.AdPostingApiService
.UponReceiving("a POST advertisement request to create a job ad with granular location")
.With(
new ProviderServiceRequest
{
Method = HttpVerb.Post,
Path = AdvertisementLink,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Content-Type", RequestContentTypes.AdvertisementVersion1 },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
},
Body = new AdvertisementContentBuilder(allFieldsWithGranularLocationInitializer)
.WithRequestCreationId(CreationIdForAdWithMinimumRequiredData)
.Build()
}
)
.WillRespondWith(
new ProviderServiceResponse
{
Status = 202,
Headers = new Dictionary<string, string>
{
{ "Content-Type", ResponseContentTypes.AdvertisementVersion1 },
{ "Location", location },
{ "X-Request-Id", RequestId }
},
Body = new AdvertisementResponseContentBuilder(allFieldsWithGranularLocationInitializer)
.WithId(advertisementId)
.WithState(AdvertisementState.Open.ToString())
.WithLink("self", link)
.WithLink("view", viewRenderedAdvertisementLink)
.WithGranularLocationState(null)
.Build()
});
var requestModel = new AdvertisementModelBuilder(allFieldsWithGranularLocationInitializer)
.WithRequestCreationId(CreationIdForAdWithMinimumRequiredData)
.Build();
AdvertisementResource result;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
result = await client.CreateAdvertisementAsync(requestModel);
}
AdvertisementResource expectedResult = new AdvertisementResourceBuilder(allFieldsWithGranularLocationInitializer)
.WithId(new Guid(advertisementId))
.WithLinks(advertisementId)
.WithGranularLocationState(null)
.Build();
result.ShouldBeEquivalentTo(expectedResult);
}
public async Task GetNonExistentAdvertisementStatus()
{
const string advertisementId = "9b650105-7434-473f-8293-4e23b7e0e064";
OAuth2Token oAuth2Token = new OAuth2TokenBuilder().Build();
var link = $"{AdvertisementLink}/{advertisementId}";
this.Fixture.AdPostingApiService
.UponReceiving("a HEAD advertisement request for a non-existent advertisement")
.With(new ProviderServiceRequest
{
Method = HttpVerb.Head,
Path = link,
Headers = new Dictionary<string, string>
{
{ "Authorization", "Bearer " + oAuth2Token.AccessToken },
{ "Accept", $"{ResponseContentTypes.AdvertisementVersion1}, {ResponseContentTypes.AdvertisementErrorVersion1}" },
{ "User-Agent", AdPostingApiFixture.UserAgentHeaderValue }
}
})
.WillRespondWith(new ProviderServiceResponse
{
Status = 404,
Headers = new Dictionary<string, string> { { "X-Request-Id", RequestId } }
});
AdvertisementNotFoundException actualException;
using (AdPostingApiClient client = this.Fixture.GetClient(oAuth2Token))
{
actualException = await Assert.ThrowsAsync<AdvertisementNotFoundException>(
async () => await client.GetAdvertisementStatusAsync(new Uri(this.Fixture.AdPostingApiServiceBaseUri, link)));
}
actualException.ShouldBeEquivalentToException(new AdvertisementNotFoundException(RequestId));
}