public static void BaseInitialize(TestContext context)
{
TestClassBase.Initialize(context);
// load ptfconfig properties
EnvironmentConfig.LoadParameters(BaseTestSite);
EnvironmentConfig.CheckParameters(BaseTestSite);
// initialize controller adapter
SutAdapter = BaseTestSite.GetAdapter <ISUTControlAdapter>();
AsyncSutAdapter = new SUTControlAdapterAsync(SutAdapter);
// initialize client adapter
ClientAdapter = BaseTestSite.GetAdapter <IMSADFSPIPClientAdapter>();
if (!m_sslCertBinded)
{
ClientAdapter.BindCertificate(new X509Certificate2(
EnvironmentConfig.TLSServerCertificatePath,
EnvironmentConfig.TLSServerCertificatePassword));
m_sslCertBinded = true;
}
// initialize server data model and handler factory
ServerDataModel = ServerDataModel.InitiateServerDataModel();
}
public void S3_RemoveApplication_NotPublished_Fail()
{
// remove the published application
ServerDataModel.ResetPublishedEndpoint();
// trigger the client to remove an application asynchronously
// so that it does not block the main thread
var sut = AsyncSutAdapter.TriggerRemoveApplicationAsync();
TestSite.Log.Add(LogEntryKind.Comment, "Triggering proxy client to remove a web application");
// start receiving client request
// when request comes, forward it to the corresponding handler
while ((CurrentRequest = ClientAdapter.ExpectRequest()) != null)
{
TestSite.Log.Add(LogEntryKind.Comment, "Received request for " + CurrentRequest.RequestUri.AbsolutePath);
CurrentHandler = (ProxyRequestHandlerBase)Factory.GetRequestHandler(CurrentRequest);
TestSite.Assert.IsTrue(CurrentHandler.VerifyRequest(out VerifyMessage), VerifyMessage);
if (CurrentHandler is DeleteProxyPublishSettingsRequestHandler)
{
CurrentResponse = ((DeleteProxyPublishSettingsRequestHandler)CurrentHandler)
.GetNotFoundResponse();
}
else
{
CurrentResponse = CurrentHandler.GetResponse();
}
ClientAdapter.SendResponse(CurrentResponse);
TestSite.Log.Add(LogEntryKind.Comment, "Response has been sent to the client.");
}
TestSite.Assert.IsFalse(sut.Result.Return, "Client acted correctly with 404 response.");
}
public HttpResponseMessage GetSuccessResponse()
{
ServerDataModel.AddProxyTrustCertificate(JSONObject.Parse <ProxyTrustRenewal>(Request.Content.GetString()));
return(new HttpResponseMessage(200)
{
ContentType = TextHtmlContent
});
}
public HttpResponseMessage GetSuccessResponse()
{
var response = new HttpResponseMessage(200)
{
ContentType = ApplicationJsonContent
};
response.Content.SetString(ServerDataModel.GetSerializedProxyRelyingPartyTrust());
return(response);
}
public HttpResponseMessage GetSuccessResponse()
{
var response = new HttpResponseMessage(200)
{
ContentType = TextHtmlContent
};
response.Content.SetString(ServerDataModel.GetFederationMetadata());
return(response);
}
public HttpResponseMessage GetSuccessResponse()
{
var response = new HttpResponseMessage(200)
{
ContentType = TextHtmlContent
};
response.Content.SetString(ServerDataModel.GetSerializedStsConfiguration());
return(response);
}
public override bool VerifyRequest(out string message)
{
// parse query string parameters
var param = ParseFedauthQueryString(Request.RequestUri.Query);
// check version
if (param.Version != "1.0")
{
message = "Version of the protocol MUST be 1.0.";
return(false);
}
// check Action
if (!param.Action.EqualsIgnoreCase("signin"))
{
message = "Action on authentication request MUST be signin";
return(false);
}
// check Realm
if (!param.Realm.EqualsIgnoreCase(Constraints.DefaultProxyRelyingPartyTrustIdentifier))
{
message = "Realm MUST be [Client State].ProxyRelyingPartyTrustIdentifier.";
return(false);
}
// retrieve published application
var endpoint = ServerDataModel.GetPublishedEndpoint((string)DynamicObject.InitialUrl);
if (endpoint == null)
{
message = "Endpoint with the url was not found.";
return(false);
}
// check AppRealm
// There is an TDI here, the AppRealm is the relying party ID, not the URL of the endpoint
if (!param.AppRealm.EqualsIgnoreCase(endpoint.ADFSRelyingPartyID))
{
message = "AppRealm must match the relying party ID.";
return(false);
}
// check ReturnUrl
if (!param.ReturnUrl.EqualsIgnoreCase(endpoint.FrontendUrl))
{
message = "ReturnUrl must match the URL of the published application.";
return(false);
}
// validation passed
message = "Query string parameters vefified.";
return(true);
}
protected override void TestInitialize()
{
base.TestInitialize();
Factory.RegisterRequestHandler <PostProxyEstablishTrustRequestHandler>();
Factory.RegisterRequestHandler <PostProxyTrustRequestHandler>();
Factory.RegisterRequestHandler <GetProxyTrustRequestHandler>();
Factory.RegisterRequestHandler <GetFederationMetadataRequestHandler>();
ServerDataModel.SetPublishedEndpoint();
}
public override HttpResponseMessage GetResponse()
{
var requestedEntry = JSONObject.Parse <StoreEntry>(Request.Content.GetString());
ServerDataModel.AddStoreEntry(requestedEntry);
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
ContentType = ApplicationJsonContent
};
response.Content.SetString(ServerDataModel.GetSerializedStoreEntry(requestedEntry.key));
return(response);
}
protected override void TestInitialize()
{
base.TestInitialize();
// initialize mock client to visit the proxy
MockClient = new MockClient(IPAddress.Parse(EnvironmentConfig.SUTIP));
// make sure there is an application published
ServerDataModel.SetPublishedEndpoint();
// make sure the application proxy is deployed
TestSite.Assert.IsTrue(SutAdapter.IsApplicationProxyConfigured(),
"The Application must be deployed before running this test case.");
}
protected override void TestInitialize()
{
base.TestInitialize();
// register request handlers used by this test class
Factory.RegisterRequestHandler <DeleteProxyPublishSettingsRequestHandler>();
// make sure the application proxy is installed on the client
TestSite.Assert.IsTrue(SutAdapter.IsApplicationProxyConfigured(),
"Application proxy must be configured before removing applications");
// set an application published before removing it
ServerDataModel.SetPublishedEndpoint();
}
/// <summary>
/// Get an instance of ServerDataModel.
/// </summary>
/// <returns>
/// An instance of ServerDataModel
/// </returns>
public static ServerDataModel InitiateServerDataModel()
{
// if the instance already exists
if (_model != null)
{
return(_model);
}
// or create a new instance with default settings
_model = new ServerDataModel();
_storeDataFile = EnvironmentConfig.DataStorePath;
// XML-syncing is disabled at present
// the ServerDataModel instance gets instantiated first,
// if the value stored in the XML file is not the same
// as the current value, it overrides the current value.
return(_model);
}
public void S5_WebAccess_AdfsPreauth_QueryStringBased_Success()
{
// make a request to the proxy with authToken
var client = MockClient.MakeWebAccessRequestAsync(new Uri(EnvironmentConfig.App1Url),
ServerDataModel.GetAuthToken());
TestSite.Log.Add(LogEntryKind.Comment, "Sending preauthenticated web access request to the proxy...");
// auto-hanlde all other requests to the server until we get
// the request to the web application.
var replayedRequest = WaitForReqeust(EnvironmentConfig.App1Url);
// once we get the redirected request, it means that the proxy has
// validated the authToken and redirect the request to the internal
// url correctly.
TestSite.Assert.IsTrue(replayedRequest != null, "Preauthenticated request successfully redirected.");
// After successful preauthentication the proxy MUST remove the authToken
// parameter with its value before replaying the request to the internal URL.
TestSite.Assert.IsTrue(!replayedRequest.RequestUri.Query.ContainsIgnoreCase("authToken"),
"No authToken parameter contained in the replayed request.");
}
public void S6_ActiveClientAuth_AccessDenied()
{
ServerDataModel.ResetPublishedEndpoint();
TestSite.Log.Add(LogEntryKind.Comment, "Reset Published Endpoint");
System.Threading.Thread.Sleep(1000 * 30);
// make a request to the proxy with authToken
var sut = AsyncSutAdapter.TriggerPublishNonClaimsAppAsync();
TestSite.Log.Add(LogEntryKind.Comment, "Triggering proxy client to publish a web application");
System.Threading.Thread.Sleep(1000 * 60);
TestSite.Log.Add(LogEntryKind.Comment, "Client start to access webapp");
System.Threading.Thread.Sleep(1000 * 60);
// make a request to the proxy with authToken
var client = MockClient.MakeWebRequestWithBasicAuth(new Uri(EnvironmentConfig.App2Url),
ServerDataModel.GetIncorrectBasicAuthorizationHeader());
TestSite.Assert.IsTrue(client.StatusCode == HttpStatusCode.Unauthorized, "Preauthenticated request failed redirected as access denied.");
}
public HttpResponseMessage GetSuccessResponse()
{
var response = new HttpResponseMessage(200)
{
ContentType = ApplicationJsonContent
};
// if the absolute path ENDs with store url, it means to get all the store entries
if (Regex.IsMatch(Request.RequestUri.AbsolutePath, Constraints.StoreUrl + "$", RegexOptions.IgnoreCase))
{
response.Content.SetString(ServerDataModel.GetSerializedStoreEntry());
}
else
{
// otherwise, get a specific entry
var entryKey = Request.RequestUri.AbsolutePath.Substring(
Request.RequestUri.AbsolutePath.IndexOf(Constraints.StoreUrl, 0,
StringComparison.InvariantCultureIgnoreCase) +
Constraints.StoreUrl.Length + 1);
response.Content.SetString(ServerDataModel.GetSerializedStoreEntry(entryKey));
}
return(response);
}
public HttpResponseMessage GetSuccessResponse()
{
ServerDataModel.AddProxyRelyingPartyTrust(JSONObject.Parse <ProxyRelyingPartyTrust>(Request.Content.GetString()));
return(new HttpResponseMessage(200));
}
public ProxyRequestHandlerFactory(ServerDataModel serverDataModel)
{
_handlerPool = new List <IRequestHandler>();
_serverDataModel = serverDataModel;
}
