public virtual void PublishContestResultToNotExistingContestTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishContestResultToNotExistingContestTest");
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
//once the contest is published test publishing contest results
//create dummy contest results, they have to match contest metric definitions
var results = GenerateDummyResults(LineSeriesMetric, BoxSummaryMetric);
//generate new valid guid, but to contest that does not exist
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(Guid.NewGuid().ToString(), "Mock technique", "Mock technique description", results, score, FakeBaseData);
//reuse the same ticket and valid credentials...
//typically it would be another user, but it doesn't matter for test purposes (it may be so the contest creator also publishes results)
ContestResultsPublishedResponse resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
Assert.AreEqual(ResponseStatus.STATUS_FAILURE, resultPublishedResponse.Status);
Assert.IsNotNull(resultPublishedResponse.ErrorMessage);
Assert.AreEqual("The contest of the given id does not exists.", resultPublishedResponse.ErrorMessage);
}
public virtual void PublishContestWithIncorrectBaselineResultsTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishContestWithIncorrectBaselineResultsTest");
//create dummy contest results that are incorrect (they do not match contest metric definitions)
var seriesMetric = MockContestResultsHelper.CreateDummySeriesMetricResults("Not matching series metric name", "Some description");
var boxMetric = MockContestResultsHelper.CreateDummyBoxSummaryMetricResults("Not matchin box metric name", "Some description");
var resultDataset1 = CreateDummyResultsDTO("Dataset 1", seriesMetric, boxMetric); //the name of metric won't match with metric definitions in the contest
var allResults = new List <DatasetResultsDTO>()
{
resultDataset1
};
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID, "Baseline", "Baseline technique description", allResults, score, FakeBaseData);
dummyContest.BaselineResults = contestResults;
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_FAILURE, response.Status);
Assert.IsNotNull(response.ErrorMessage);
Assert.AreEqual("Baseline results failed to be saved. Metric results does not match metrics defined in the contest.", response.ErrorMessage);
}
public virtual void PublishEmptyContestResultTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishEmptyContestResultTest");
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
//once the contest is published test publishing contest results
//create dummy contest results (they have to match contest metric definitions
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID, "Mock technique", "Mock technique description", new List <DatasetResultsDTO>(), score, FakeBaseData);
//reuse the same ticket and valid credentials...
//typically it would be another user, but it doesn't matter for test purposes (it may be so the contest creator also publishes results)
ContestResultsPublishedResponse resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
//cannot publish empty results
Assert.AreEqual(ResponseStatus.STATUS_FAILURE, resultPublishedResponse.Status);
Assert.IsNotNull(resultPublishedResponse.ErrorMessage);
Assert.AreEqual("Metric results does not match metrics defined in the contest.", resultPublishedResponse.ErrorMessage);
}
public virtual void PublishContestWithBaselineResultsTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishContestWithBaselineResultsTest");
//create dummy contest results (they have to match contest metric definitions
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID, "Baseline", "Baseline technique description", DummyCorrectResults, score, FakeBaseData);
dummyContest.BaselineResults = contestResults;
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
Assert.IsNull(response.ErrorMessage);
Assert.IsNotNull(response.ContestWebsiteLink);
}
private static async Task <ContestResults> GetContest(string eventID)
{
APIService srv = new APIService();
ContestModel model = new ContestModel();
Dictionary <string, string> p = new Dictionary <string, string>();
p.Add("eventId", string.Format("'{0}'", eventID));
model.CommandModel.SessionToken = await App.GetUsersSession();
model.CommandModel.ServiceName = "Contest";
model.CommandModel.Action = "GetContestForEvent";
model.CommandModel.Parameters = p;
ContestResults result = null;
var cache = BlobCache.UserAccount;
var cachedContestsPromise = cache.GetAndFetchLatest(
"contests",
() => srv.GetContestsForEvent(model.CommandModel),
offset =>
{
TimeSpan elapsed = DateTimeOffset.Now - offset;
return(elapsed > new TimeSpan(hours: 0, minutes: 10, seconds: 0));
});
cachedContestsPromise.Subscribe(subscribedContests =>
{
result = subscribedContests;
});
result = await cachedContestsPromise.FirstOrDefaultAsync();
return(result);
}
public static ContestResults PrepareBaselineContestRestults(string contestId,
TraceLabSDK.Types.Contests.TLExperimentResults experimentResults,
string techniqueName,
string techniqueDescription)
{
List <DatasetResultsDTO> results = new List <DatasetResultsDTO>();
foreach (TraceLabSDK.Types.Contests.DatasetResults dataset in experimentResults.DatasetsResults)
{
results.Add(new DatasetResultsDTO(dataset));
}
var baselineResults = new ContestResults(contestId, techniqueName, techniqueDescription, results, experimentResults.Score, experimentResults.BaseData);
return(baselineResults);
}
public virtual void PublishContestResultTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishContestResultTest");
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
//once the contest is published test publishing contest results
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID,
"Mock technique", "Mock technique description", DummyCorrectResults, score, FakeBaseData);
//reuse the same ticket and valid credentials...
//typically it would be another user, but it doesn't matter for test purposes (it may be so the contest creator also publishes results)
ContestResultsPublishedResponse resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, resultPublishedResponse.Status);
Assert.IsNull(resultPublishedResponse.ErrorMessage);
//create other set of results for the same metrics
var lineSeriesMetric = MockContestResultsHelper.CreateDummySeriesMetricResults(m_mockSeriesMetricName, "Mock series metric description");
var boxSummaryMetric = MockContestResultsHelper.CreateDummyBoxSummaryMetricResults(m_mockBoxPlotMetricName, "Mock box plot metric description");
var otherCorrectResults = GenerateDummyResults(lineSeriesMetric, boxSummaryMetric);
score = random.NextDouble();
contestResults = new ContestResults(dummyContest.ContestGUID, "Another technique", "Another technique description", otherCorrectResults, score, FakeBaseData);
resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, resultPublishedResponse.Status);
Assert.IsNull(resultPublishedResponse.ErrorMessage);
Assert.IsNotNull(resultPublishedResponse.ContestWebsiteLink);
}
public virtual void PublishNotMatchingContestResultTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishNotMatchingContestResultTest");
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
//once the contest is published test publishing contest results
//create dummy contest results, that have metric that does not match contest metric definitions
var seriesMetric = MockContestResultsHelper.CreateDummySeriesMetricResults("Not matching series metric name", "Some description");
var boxMetric = MockContestResultsHelper.CreateDummyBoxSummaryMetricResults("Not matchin box metric name", "Some description");
var resultDataset1 = CreateDummyResultsDTO("Dataset 1", seriesMetric, boxMetric); //the name of metric won't match with metric definitions in the contest
var allResults = new List <DatasetResultsDTO>()
{
resultDataset1
};
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID, "Mock technique", "Mock technique description", allResults, score, FakeBaseData);
//reuse the same ticket and valid credentials...
//typically it would be another user, but it doesn't matter for test purposes (it may be so the contest creator also publishes results)
ContestResultsPublishedResponse resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
//cannot publish empty results
Assert.AreEqual(ResponseStatus.STATUS_FAILURE, resultPublishedResponse.Status);
Assert.IsNotNull(resultPublishedResponse.ErrorMessage);
Assert.AreEqual("Metric results does not match metrics defined in the contest.", resultPublishedResponse.ErrorMessage);
}
public void ExecutePublishResults(string ticket, string username, Callback <ContestResultsPublishedResponse> publishingResultsCallback)
{
//get the unitname to be loaded from workspace
string experimentResultsUnitname = SelectedBenchmark.BenchmarkInfo.ExperimentResultsUnitname;
//create an experiment workspace wrapper with experiment info
var benchmarkWorkspaceWrapper = new ExperimentWorkspaceWrapper(m_workspace, SelectedBenchmark.BenchmarkInfo.Id);
var experimentResults = benchmarkWorkspaceWrapper.Load(experimentResultsUnitname) as TraceLabSDK.Types.Contests.TLExperimentResults;
if (experimentResults != null)
{
ContestResults results = BenchmarkResultsHelper.PrepareBaselineContestRestults(SelectedBenchmark.BenchmarkInfo.Id,
experimentResults,
TechniqueName, TechniqueDescription);
WebService.PublishContestResults(ticket, username, results, publishingResultsCallback);
}
else
{
throw new InvalidOperationException("The experiment results outputed in the contest are empty! Empty results cannot be publish! ");
}
}
public virtual void PublishContestResultAfterDeadlineTest()
{
//authenticate with valid credentials
AuthenticationResponse authenticationResponse = AuthenticateSync(ValidCredentials);
//check if authentication succeed
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, authenticationResponse.Status);
//create dummy contest
var dummyContest = CreateDummyContest("PublishContestResultAfterDeadlineTest");
//set some deadline, that has already passed
dummyContest.SetDeadline(new DateTime(1999, 1, 12));
//the authentication provides the ticket necessary to publish the contest
ContestPublishedResponse response = PublishContestSync(authenticationResponse.Ticket, ValidCredentials.Username, dummyContest);
Assert.AreEqual(ResponseStatus.STATUS_SUCCESS, response.Status);
//once the contest is published test publishing contest results
//create dummy contest results
var results = GenerateDummyResults(LineSeriesMetric, BoxSummaryMetric);
Random random = new Random();
double score = random.NextDouble();
ContestResults contestResults = new ContestResults(dummyContest.ContestGUID, "Mock technique", "Mock technique description", results, score, FakeBaseData);
//reuse the same ticket and valid credentials...
//typically it would be another user, but it doesn't matter for test purposes (it may be so the contest creator also publishes results)
ContestResultsPublishedResponse resultPublishedResponse = PublishContestResultSync(authenticationResponse.Ticket, ValidCredentials.Username, contestResults);
Assert.AreEqual(ResponseStatus.STATUS_FAILURE, resultPublishedResponse.Status);
Assert.IsNotNull(resultPublishedResponse.ErrorMessage);
Assert.AreEqual("The contest results could not been published, because it is passed the deadline.", resultPublishedResponse.ErrorMessage);
}
private void LoadContestResults()
{
Contest contest = Contest.GetLastContest();
ContestResults cResults = new ContestResults();
cResults.GetContestVideosForContest(contest.ContestID);
ViewBag.ContestResults = cResults;
}
protected ContestResultsPublishedResponse PublishContestResultSync(string ticket, string username, ContestResults contestResults)
{
ContestResultsPublishedResponse response = DoAsyncCallAsSynchronous <ContestResultsPublishedResponse>(
(Callback <ContestResultsPublishedResponse> callback) =>
{
WebService.PublishContestResults(ticket, username, contestResults, callback);
});
return(response);
}
