public Tests()
{
string baseDir = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(baseDir.Substring(0, baseDir.LastIndexOf("\\bin")));
AdapterSettings adapterSettings = new AdapterSettings();
adapterSettings.AppendSettings(new AppSettingsReader("App.config"));
FileInfo log4netConfig = new FileInfo("Log4net.config");
log4net.Config.XmlConfigurator.Configure(log4netConfig);
_dataLayer = new ebDataLayer(adapterSettings);
_scenarios = Utility.Read<Scenarios>("Scenarios.xml");
}
public Tests()
{
string baseDir = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(baseDir.Substring(0, baseDir.LastIndexOf("\\bin")));
AdapterSettings adapterSettings = new AdapterSettings();
adapterSettings["ProjectName"] = project;
adapterSettings["ApplicationName"] = app;
string appConfigPath = string.Format("App_Data\\{0}.{1}.config", project, app);
adapterSettings.AppendSettings(new AppSettingsReader(appConfigPath));
_dataLayer = new SPPIDDataLayer(adapterSettings);
_scenarios = org.iringtools.utility.Utility.Read<Scenarios>("Scenarios.xml");
}
public async Task UpdateAsync(string id, Scenarios scenario)
{
await _scenarios.ReplaceOneAsync(s => s.Id == id, scenario);
}
public PageFrontMenu()
{
InitializeComponent();
StackPanel panelContent = new StackPanel();
panelContent.Margin = new Thickness(10, 0, 10, 0);
panelContent.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
panelContent.VerticalAlignment = System.Windows.VerticalAlignment.Center;
Panel panelLogo = UICreator.CreateGameLogo();
panelLogo.Margin = new Thickness(0, 0, 0, 20);
panelContent.Children.Add(panelLogo);
Button btnNewGame = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "200"));
btnNewGame.Click += btnNewGame_Click;
panelContent.Children.Add(btnNewGame);
Button btnPlayScenario = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "205"));
btnPlayScenario.IsEnabled = Scenarios.GetNumberOfScenarios() > 0;
btnPlayScenario.Click += btnPlayScenario_Click;
panelContent.Children.Add(btnPlayScenario);
Button btnLoadGame = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "201"));
btnLoadGame.Click += btnLoadGame_Click;
panelContent.Children.Add(btnLoadGame);
Button btnSettings = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "202"));
btnSettings.Click += btnSettings_Click;
btnSettings.IsEnabled = false;
panelContent.Children.Add(btnSettings);
Button btnCredits = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "203"));
btnCredits.Click += btnCredits_Click;
// btnCredits.IsEnabled = false;
panelContent.Children.Add(btnCredits);
Button btnExitGame = createMenuButton(Translator.GetInstance().GetString("PageFrontMenu", "204"));
btnExitGame.Click += btnExitGame_Click;
panelContent.Children.Add(btnExitGame);
base.setTopMenu(new PageTopMenu());
base.hideNavigator();
base.hideBottomMenu();
base.setContent(panelContent);
base.setHeaderContent(Translator.GetInstance().GetString("PageFrontMenu", "1001"));
showPage(this);
}
protected int SetupScenarioList(int layerIndex)
{
// right side group
RelativeRect rect = new RelativeRect(RelativeLoc.XRightBorder + RelativeLoc.BorderOffset, RelativeLoc.YUpper + RelativeLoc.BorderOffset, RelativeSize.TwoColumnWidth, RelativeSize.SevenEightsHeight, OriginLocation.UpperRight);
GridLayoutGroup scenarioGrid = new GridLayoutGroup(rect, 15, 2);
Columns[1] = scenarioGrid;
scenarioGrid.MaxChildSize = MenuCommon.ButtonHeight.Paramater;
scenarioGrid.SetColSpan(0, 1);
scenarioGrid.SetColSpan(1, 6);
scenarioGrid.SetColSpan(7, 4);
scenarioGrid.SetColSpan(12, 3);
// Scenario header
scenarioGrid.AddChild(new Header(new RelativeRect(), MenuRes.Scenario));
ButtonScrollList scenarioList = new ButtonScrollList(RelativeRect.Full);
scenarioList.DesiredRows = 6;
foreach (var scenario in Scenarios.GetScenarioList())
{
scenarioList.AddItem(scenario.Name, scenario);
}
scenarioList.SelectedIndexChanged += ScenarioList_SelectedIndexChanged;
scenarioList.FillMode = UIFillModes.Stretch4Quad;
scenarioGrid.AddChild(scenarioList);
SecenarioText = new TextArea(RelativeRect.Full, string.Empty, MenuManager.MainFont, ThemeManager.GetThemeAsset("ui/TextEntryBackground.png"));
SecenarioText.DefaultMaterial.Color = Color.Gray;
SecenarioText.DesiredRows = 8;
SecenarioText.BorderPadding = 4;
SecenarioText.MiniumElementHeight = 20;
scenarioGrid.AddChild(SecenarioText);
// sensor scan complexity
// get data from selected scenario
scenarioGrid.AddChild(MakeGridLabel(MenuRes.Variation));
VariationList = new SpinSelector(new RelativeRect(), MenuRes.DefaultVariation.Split(";".ToCharArray()), 0);
VariationList.ValueChanged += ScenarioVariation_ValueChanged;
scenarioGrid.AddChild(VariationList);
// replace with variation info
VariationText = new TextArea(RelativeRect.Full, string.Empty, MenuManager.MainFont, ThemeManager.GetThemeAsset("ui/TextEntryBackground.png"));
VariationText.DefaultMaterial.Color = Color.Gray;
VariationText.DesiredRows = 6;
VariationText.BorderPadding = 4;
VariationText.MiniumElementHeight = 20;
scenarioGrid.AddChild(VariationText);
AddElement(Columns[1], layerIndex + 1);
scenarioList.SetSelectedIndex(0);
return(layerIndex + 1);
}
internal static MockIdentifier GetMockIdentifier(Scenarios scenario, ProtocolVersion providerVersion)
{
return GetMockIdentifier(scenario, providerVersion, false);
}
public static void GoToScenarioStaticMethod(Scenarios scenarios)
{
GoToScenario(scenarios);
}
public Scenario GetScenario(uint id) => Scenarios.ContainsKey(id) ? Scenarios[id] : null;
public void Refresh()
{
_objects = new Objects(_jee);
if(_objects.Loaded)
{
_eqLogics = new EqLogics(_jee, this);
if (_eqLogics.Loaded)
{
_commands = new Commands(_jee, this);
if (_commands.Loaded)
{
_plugins = new Plugins(_jee);
if (_plugins.Loaded)
{
_scenarios = new Scenarios(_jee);
if (_scenarios.Loaded)
{
_messages = new Messages(_jee);
if (_messages.Loaded)
{
_loaded = true;
}
else
{
_error = _scenarios.Error;
_loaded = false;
}
}
else
{
_error = _messages.Error;
_loaded = false;
}
}
else
{
_error = _plugins.Error;
_loaded = false;
}
}
else
{
_error = _commands.Error;
_loaded = false;
}
}
else
{
_error = _eqLogics.Error;
_loaded = false;
}
}
else
{
_error = _objects.Error;
_loaded = false;
}
}
internal static void SetAuthenticationFromScenario(Scenarios scenario, DotNetOpenId.Provider.IAuthenticationRequest request)
{
Assert.IsTrue(request.IsReturnUrlDiscoverable);
switch (scenario) {
case TestSupport.Scenarios.ExtensionFullCooperation:
case TestSupport.Scenarios.ExtensionPartialCooperation:
case TestSupport.Scenarios.AutoApproval:
// immediately approve
request.IsAuthenticated = true;
break;
case TestSupport.Scenarios.AutoApprovalAddFragment:
request.SetClaimedIdentifierFragment("frag");
request.IsAuthenticated = true;
break;
case TestSupport.Scenarios.ApproveOnSetup:
request.IsAuthenticated = !request.Immediate;
break;
case TestSupport.Scenarios.AlwaysDeny:
request.IsAuthenticated = false;
break;
default:
throw new InvalidOperationException("Unrecognized scenario");
}
}
public static Identifier GetDelegateUrl(Scenarios scenario)
{
return GetDelegateUrl(scenario, false);
}
internal static UriIdentifier GetOPIdentityUrl(Scenarios scenario, bool useSsl)
{
var args = new Dictionary<string, string> {
{ "user", scenario.ToString() },
};
return new UriIdentifier(GetFullUrl("/" + OPDefaultPage, args, useSsl));
}
internal static ServiceEndpoint GetServiceEndpoint(Scenarios scenario, ProtocolVersion providerVersion, int servicePriority, bool useSsl)
{
return ServiceEndpoint.CreateForClaimedIdentifier(
GetIdentityUrl(scenario, providerVersion, useSsl),
GetDelegateUrl(scenario, useSsl),
GetFullUrl("/" + ProviderPage, null, useSsl),
new string[] { Protocol.Lookup(providerVersion).ClaimedIdentifierServiceTypeURI },
servicePriority,
10
);
}
internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId, bool useSslOpIdentifier, bool useSslProviderEndpoint)
{
var fields = new Dictionary<string, string> {
{ "user", scenario.ToString() },
};
Uri opEndpoint = GetFullUrl(DirectedProviderEndpoint, fields, useSslProviderEndpoint);
Uri opIdentifier = GetOPIdentityUrl(scenario, useSslOpIdentifier);
ServiceEndpoint se = ServiceEndpoint.CreateForProviderIdentifier(
opIdentifier,
opEndpoint,
new string[] { Protocol.v20.OPIdentifierServiceTypeURI },
10,
10
);
// Register the Claimed Identifier that directed identity will choose so that RP
// discovery on that identifier can be mocked up.
MockHttpRequest.RegisterMockXrdsResponse(expectedClaimedId, se);
return new MockIdentifier(opIdentifier, new ServiceEndpoint[] { se });
}
internal static MockIdentifier GetMockOPIdentifier(Scenarios scenario, UriIdentifier expectedClaimedId)
{
return GetMockOPIdentifier(scenario, expectedClaimedId, false, false);
}
internal static MockIdentifier GetMockIdentifier(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl)
{
ServiceEndpoint se = GetServiceEndpoint(scenario, providerVersion, 10, useSsl);
return new MockIdentifier(GetIdentityUrl(scenario, providerVersion, useSsl), new ServiceEndpoint[] { se });
}
public async Task <IActionResult> Get(string iata)
{
var result = await _mediator.ExecuteAsync(Scenarios.GetAirportInformation(iata));
return(result.ToObjectResult());
}
public static Identifier GetDelegateUrl(Scenarios scenario, bool useSsl)
{
return new UriIdentifier(GetFullUrl("/" + scenario, null, useSsl));
}
public void GivenICreatedCategory(string categoryName) => Scenarios.CreateCategory(categoryName);
public void OnTimer()
{
try
{
if (StoryProgression.Main == null)
{
return;
}
Scenarios.IncStat("OnTimer Try");
if (mInTimer)
{
return;
}
mWatch.Restart();
try
{
mInTimer = true;
mRunning = true;
if (GetValue <ShowStartScreenOption, bool>())
{
FilePersistence.ImportFromTuning("NRaas.StoryProgression.Tuning");
if (!GetValue <ProgressionOption, bool>())
{
if (AcceptCancelDialog.Show(Localize("Welcome")))
{
GetOption <ProgressionOption>().SetValue(true);
new InitialHomelessScenario().Post(Households, true, false);
}
}
}
GetOption <ShowStartScreenOption>().SetValue(false);
if (GetValue <ProgressionOption, bool>())
{
int currentInterval = LifeSpan.GetHumanAgeSpanLength();
if (GetValue <LastAskedIntervalOption, int>() != currentInterval)
{
if (AcceptCancelDialog.Show(Localize("AgeSpan")))
{
AdjustSpeedForAgeSpan((float)currentInterval / GetValue <SavedIntervalOption, int>());
GetOption <SavedIntervalOption>().SetValue(currentInterval);
}
GetOption <LastAskedIntervalOption>().SetValue(currentInterval);
}
}
Update(false, false);
}
finally
{
mInTimer = false;
}
Scenarios.IncStat("OnTimer Complete");
}
catch (Exception exception)
{
Common.Exception(UnlocalizedName, exception);
}
}
public async Task IssueCredentialThrowsExceptionCredentialInvalidState()
{
//Establish a connection between the two parties
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
// Create an issuer DID/VK. Can also be created during provisioning
var issuer = await Did.CreateAndStoreMyDidAsync(_issuerWallet.Wallet,
new { seed = TestConstants.StewardSeed }.ToJson());
// Create a schema and credential definition for this issuer
var(definitionId, _) = await Scenarios.CreateDummySchemaAndNonRevokableCredDef(_issuerWallet, _schemaService, issuer.Did,
new[] { "dummy_attr" });
var offerConfig = new OfferConfiguration
{
IssuerDid = issuer.Did,
CredentialDefinitionId = definitionId
};
// Send an offer to the holder using the established connection channel
var(message, _) = await _credentialService.CreateOfferAsync(_issuerWallet, offerConfig, issuerConnection.Id);
_messages.Add(message);
// Holder retrieves message from their cloud agent
var credentialOffer = FindContentMessage <CredentialOfferMessage>(_messages);
// Holder processes the credential offer by storing it
var holderCredentialId =
await _credentialService.ProcessOfferAsync(_holderWallet, credentialOffer, holderConnection);
// Holder creates master secret. Will also be created during wallet agent provisioning
await AnonCreds.ProverCreateMasterSecretAsync(_holderWallet.Wallet, TestConstants.DefaultMasterSecret);
// Holder accepts the credential offer and sends a credential request
var(request, _) = await _credentialService.CreateRequestAsync(_holderWallet, holderCredentialId);
_messages.Add(request);
// Issuer retrieves credential request from cloud agent
var credentialRequest = FindContentMessage <CredentialRequestMessage>(_messages);
Assert.NotNull(credentialRequest);
// Issuer processes the credential request by storing it
var issuerCredentialId =
await _credentialService.ProcessCredentialRequestAsync(_issuerWallet, credentialRequest, issuerConnection);
// Issuer accepts the credential requests and issues a credential
var(credential, _) = await _credentialService.CreateCredentialAsync(_issuerWallet, issuerCredentialId,
new List <CredentialPreviewAttribute> {
new CredentialPreviewAttribute("dummy_attr", "dummyVal")
});
_messages.Add(credential);
//Try issue the credential again
var ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() => await _credentialService.CreateCredentialAsync(_issuerWallet, issuerCredentialId));
Assert.True(ex.ErrorCode == ErrorCode.RecordInInvalidState);
}
public void NavigateToProtocolPage()
{
Scenarios.SelectedIndex = 3;
Scenarios.ScrollIntoView(Scenarios.SelectedItem);
LoadScenario(scenarios[3].ClassType);
}
internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion)
{
return GetIdentityUrl(scenario, providerVersion, false);
}
internal static UriIdentifier GetIdentityUrl(Scenarios scenario, ProtocolVersion providerVersion, bool useSsl)
{
return new UriIdentifier(GetFullUrl("/" + identityPage, new Dictionary<string, string> {
{ "user", scenario.ToString() },
{ "version", providerVersion.ToString() },
}, useSsl));
}
public void NavigateToFilePage()
{
Scenarios.SelectedIndex = 2;
Scenarios.ScrollIntoView(Scenarios.SelectedItem);
LoadScenario(scenarios[2].ClassType);
}
/*
* This function takes in a boolean value and returns a list of scenarios where the approved
* status of the scenario matches that of the input value.
*/
public static Scenarios getScenarios(bool approved, SqlConnection connection)
{
var scenarios = new Scenarios {
ScenarioList = new List <Scenario>()
};
try
{
var command = new SqlCommand(null, connection)
{
CommandText = "SELECT * " +
"FROM SCENARIOS JOIN STUDENTS ON SCENARIOS.SCENARIO_MADE_BY = STUDENTS.STUDENT_ID " +
"WHERE SCENARIO_ID != 0 AND SCENARIO_APPROVED = 1"
};
if (!approved)
{
command.CommandText = "SELECT * " +
"FROM SCENARIOS JOIN STUDENTS ON SCENARIOS.SCENARIO_MADE_BY = STUDENTS.STUDENT_ID " +
"WHERE SCENARIO_ID != 0 AND SCENARIO_APPROVED = 0";
}
// Create and prepare an SQL statement.
// Call Prepare after setting the Commandtext and Parameters.
connection.Close(); connection.Open();
command.Prepare();
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var scenario = new Scenario();
scenario.scenarioName = $"{reader["SCENARIO_NAME"]}";
scenario.scenarioID = Convert.ToInt32($"{reader["SCENARIO_ID"]}");
scenario.description = $"{reader["SCENARIO_DESCRIPTION"]}";
scenario.isActive = Convert.ToBoolean($"{reader["SCENARIO_IS_ACTIVE"]}".ToLower());
scenario.madeBy = $"{reader["STUDENT_NAME"]}";
scenario.cellFunction = $"{reader["SCENARIO_CELL_FUNCTION"]}";
scenario.cellShapeAndFeatures = $"{reader["SCENARIO_CELL_SHAPE_AND_FEATURES"]}";
scenario.cellLifespan = $"{reader["SCENARIO_CELL_LIFESPAN"]}";
scenario.cellNutrition = $"{reader["SCENARIO_CELL_NUTRITION"]}";
if ($"{reader["SCENARIO_FIRST_QUESTION"]}".Equals(""))
{
scenario.currentQuestion = 0;
}
else
{
scenario.currentQuestion = Convert.ToInt32($"{reader["SCENARIO_FIRST_QUESTION"]}");
}
scenarios.ScenarioList.Add(scenario);
}
}
}
catch (Exception ex)
{
Singleton.errorCode = "SEN08";
Singleton.writeErrorToFile(Singleton.errorCode, ex.Message, ex.StackTrace);
throw ex;
}
finally
{
connection.Close();
}
return(scenarios);
}
private void GoToTheNextScenarioButtonMethod(Scenarios scenarios)
{
GoToScenario(scenarios);
}
public static (UpdateUser, IUpdateUserResult, UpdateUserHandlerDependencies) SetupForScenario(Scenarios scenario)
{
var request = GetRequestForScenario(scenario);
var expectedResponse = GetExpectedResultForScenario(scenario, request);
var dependencies = ConfigureDependenciesForScenario(request, expectedResponse);
return(request, expectedResponse, dependencies);
}
public ScenarioBase[] GetDependentScenarios(Type[] types)
{
return(Scenarios
.Where(x => x.GetAllUsedActionTypes()
.Any(z => types.Any(y => y.Equals(z)))).ToArray());
}
private static UpdateUser GetRequestForScenario(Scenarios scenario) =>
scenario switch
{
public async Task AcceptProofRequestCredentialInvalidState()
{
//Setup a connection and issue the credentials to the holder
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
await Scenarios.IssueCredentialAsync(
_schemaService, _credentialService, _messages, issuerConnection,
holderConnection, _issuerWallet, _holderWallet, await _holderWallet.Pool, TestConstants.DefaultMasterSecret, true, new List <CredentialPreviewAttribute>
{
new CredentialPreviewAttribute("first_name", "Test"),
new CredentialPreviewAttribute("last_name", "Holder")
});
_messages.Clear();
//Requestor initialize a connection with the holder
var(_, requestorConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _holderWallet, _requestorWallet);
// Verifier sends a proof request to prover
{
var proofRequestObject = new ProofRequest
{
Name = "ProofReq",
Version = "1.0",
Nonce = "123",
RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
{
{ "first-name-requirement", new ProofAttributeInfo {
Name = "first_name"
} }
}
};
//Requestor sends a proof request
var(message, _) = await _proofService.CreateProofRequestAsync(_requestorWallet, proofRequestObject, requestorConnection.Id);
_messages.Add(message);
}
// Holder accepts the proof requests and builds a proof
//Holder retrives proof request message from their cloud agent
var proofRequest = FindContentMessage <ProofRequestMessage>();
Assert.NotNull(proofRequest);
//Holder stores the proof request
var holderProofRequestId = await _proofService.ProcessProofRequestAsync(_holderWallet, proofRequest, holderConnection);
var holderProofRecord = await _proofService.GetAsync(_holderWallet, holderProofRequestId);
var holderProofObject =
JsonConvert.DeserializeObject <ProofRequest>(holderProofRecord.RequestJson);
var requestedCredentials = new RequestedCredentials();
foreach (var requestedAttribute in holderProofObject.RequestedAttributes)
{
var credentials =
await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, holderProofObject,
requestedAttribute.Key);
requestedCredentials.RequestedAttributes.Add(requestedAttribute.Key,
new RequestedAttribute
{
CredentialId = credentials.First().CredentialInfo.Referent,
Revealed = true,
Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
}
foreach (var requestedAttribute in holderProofObject.RequestedPredicates)
{
var credentials =
await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, holderProofObject,
requestedAttribute.Key);
requestedCredentials.RequestedPredicates.Add(requestedAttribute.Key,
new RequestedAttribute
{
CredentialId = credentials.First().CredentialInfo.Referent,
Revealed = true
});
}
//Holder accepts the proof request and sends a proof
await _proofService.CreateProofAsync(_holderWallet, holderProofRequestId, requestedCredentials);
var ex = await Assert.ThrowsAsync <AgentFrameworkException>(async() => await _proofService.CreateProofAsync(_holderWallet, holderProofRequestId,
requestedCredentials));
Assert.True(ex.ErrorCode == ErrorCode.RecordInInvalidState);
}
public DebugInfoPageMiddleware(RequestDelegate next, IServerAddressesFeature serverAddresses, IHostingEnvironment hostingEnv, Scenarios scenarios)
{
_next = next;
_hostingEnv = hostingEnv;
_scenarios = scenarios;
_serverAddresses = serverAddresses;
}
public async Task <Scenarios> CreateAsync(Scenarios scenario)
{
await _scenarios.InsertOneAsync(scenario);
return(scenario);
}
public PageShowScenario()
{
this.AllScenarios = Scenarios.GetScenarios();
InitializeComponent();
}
public async Task CanConductChallengeFlow()
{
//Setup a connection and issue the credentials to the holder
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
await Scenarios.IssueCredentialAsync(
_schemaService, _credentialService, _messages, issuerConnection,
holderConnection, _issuerWallet, _holderWallet, await _holderWallet.Pool, TestConstants.DefaultMasterSecret, true, new List <CredentialPreviewAttribute>
{
new CredentialPreviewAttribute("first_name", "Test"),
new CredentialPreviewAttribute("last_name", "Holder")
});
_messages.Clear();
// Challenger sends a challenge
{
var challengeConfig = new EphemeralChallengeConfiguration
{
Name = "Test",
Type = ChallengeType.Proof,
Contents = new ProofRequestConfiguration
{
RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
{
{ "first-name-requirement", new ProofAttributeInfo {
Name = "first_name"
} }
}
}
};
var challengeConfigId = await _ephemeralChallengeService.CreateChallengeConfigAsync(_requestorWallet, challengeConfig);
(var challenge, var record) = await _ephemeralChallengeService.CreateChallengeAsync(_requestorWallet, challengeConfigId);
Assert.True(!string.IsNullOrEmpty(challenge.ChallengerName));
Assert.True(challenge.RecipientKeys.Count() == 1);
Assert.True(challenge.RecipientKeys.First() == TestConstants.DefaultVerkey);
Assert.True(challenge.ServiceEndpoint == TestConstants.DefaultMockUri);
_messages.Add(challenge);
var result = await _ephemeralChallengeService.GetChallengeStateAsync(_requestorWallet, record.Id);
Assert.True(result == ChallengeState.Challenged);
}
//Challenge responder recieves challenge
{
var challengeMessage = _messages.OfType <EphemeralChallengeMessage>().First();
var proofRequest = challengeMessage.Challenge.Contents.ToObject <ProofRequest>();
var requestedCredentials = new RequestedCredentials();
foreach (var requestedAttribute in proofRequest.RequestedAttributes)
{
var credentials =
await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, proofRequest,
requestedAttribute.Key);
requestedCredentials.RequestedAttributes.Add(requestedAttribute.Key,
new RequestedAttribute
{
CredentialId = credentials.First().CredentialInfo.Referent,
Revealed = true,
Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
});
}
foreach (var requestedAttribute in proofRequest.RequestedPredicates)
{
var credentials =
await _proofService.ListCredentialsForProofRequestAsync(_holderWallet, proofRequest,
requestedAttribute.Key);
requestedCredentials.RequestedPredicates.Add(requestedAttribute.Key,
new RequestedAttribute
{
CredentialId = credentials.First().CredentialInfo.Referent,
Revealed = true
});
}
var challenge = await _ephemeralChallengeService.CreateProofChallengeResponseAsync(
_holderWallet, challengeMessage, requestedCredentials);
_messages.Add(challenge);
}
//Challenger recieves challenge response and verifies it
{
var challengeResponseMessage = _messages.OfType <EphemeralChallengeResponseMessage>().First();
var id = await _ephemeralChallengeService.ProcessChallengeResponseAsync(_requestorWallet, challengeResponseMessage);
var result = await _ephemeralChallengeService.GetChallengeStateAsync(_requestorWallet, id);
Assert.True(result == ChallengeState.Accepted);
}
}
/// <summary>
/// Vide les propriétés de navigation.
/// </summary>
protected virtual void ClearNavigationProperties()
{
LongLabelResource = null;
ShortLabelResource = null;
Scenarios.Clear();
}
/// <summary>
/// An asynchronous task that attempts to initiate a new call to a listening UAS.
/// </summary>
/// <param name="sipTransport">The transport object to use for the send.</param>
/// <param name="dst">The destination end point to send the request to.</param>
/// <returns>True if the expected response was received, false otherwise.</returns>
private static async Task <bool> InitiateCallTaskAsync(SIPTransport sipTransport, SIPURI dst, Scenarios scenario)
{
//UdpClient hepClient = new UdpClient(0, AddressFamily.InterNetwork);
try
{
//sipTransport.SIPRequestOutTraceEvent += (localEP, remoteEP, req) =>
//{
// logger.LogDebug($"Request sent: {localEP}->{remoteEP}");
// logger.LogDebug(req.ToString());
// //var hepBuffer = HepPacket.GetBytes(localEP, remoteEP, DateTimeOffset.Now, 333, "myHep", req.ToString());
// //hepClient.SendAsync(hepBuffer, hepBuffer.Length, "192.168.11.49", 9060);
//};
//sipTransport.SIPResponseInTraceEvent += (localEP, remoteEP, resp) =>
//{
// logger.LogDebug($"Response received: {localEP}<-{remoteEP}");
// logger.LogDebug(resp.ToString());
// //var hepBuffer = HepPacket.GetBytes(remoteEP, localEP, DateTimeOffset.Now, 333, "myHep", resp.ToString());
// //hepClient.SendAsync(hepBuffer, hepBuffer.Length, "192.168.11.49", 9060);
//};
var ua = new SIPUserAgent(sipTransport, null);
ua.ClientCallTrying += (uac, resp) => logger.LogInformation($"{uac.CallDescriptor.To} Trying: {resp.StatusCode} {resp.ReasonPhrase}.");
ua.ClientCallRinging += (uac, resp) => logger.LogInformation($"{uac.CallDescriptor.To} Ringing: {resp.StatusCode} {resp.ReasonPhrase}.");
ua.ClientCallFailed += (uac, err, resp) => logger.LogWarning($"{uac.CallDescriptor.To} Failed: {err}");
ua.ClientCallAnswered += (uac, resp) => logger.LogInformation($"{uac.CallDescriptor.To} Answered: {resp.StatusCode} {resp.ReasonPhrase}.");
var audioOptions = new AudioSourceOptions {
AudioSource = AudioSourcesEnum.Silence
};
var audioExtrasSource = new AudioExtrasSource(new AudioEncoder(), audioOptions);
audioExtrasSource.RestrictFormats(format => format.Codec == AudioCodecsEnum.PCMU);
var voipMediaSession = new VoIPMediaSession(new MediaEndPoints {
AudioSource = audioExtrasSource
});
var result = await ua.Call(dst.ToString(), null, null, voipMediaSession);
if (scenario == Scenarios.uacw)
{
// Wait for the remote party to hangup the call.
logger.LogDebug("Waiting for the remote party to hangup the call...");
ManualResetEvent hangupMre = new ManualResetEvent(false);
ua.OnCallHungup += (dialog) => hangupMre.Set();
hangupMre.WaitOne();
logger.LogDebug("Call hungup by remote party.");
}
else
{
// We hangup the call after 1s.
await Task.Delay(1000);
ua.Hangup();
}
// Need a bit of time for the BYE to complete.
await Task.Delay(500);
return(result);
}
catch (Exception excp)
{
logger.LogError($"Exception InitiateCallTaskAsync. {excp.Message}");
return(false);
}
}
public async Task CreateProofRequestFromProposal()
{
var events = 0;
_eventAggregator.GetEventByType <ServiceMessageProcessingEvent>()
.Where(_ => (_.MessageType == MessageTypes.PresentProofNames.ProposePresentation ||
_.MessageType == MessageTypes.PresentProofNames.RequestPresentation ||
_.MessageType == MessageTypes.IssueCredentialNames.RequestCredential ||
_.MessageType == MessageTypes.IssueCredentialNames.IssueCredential))
.Subscribe(_ =>
{
events++;
});
// Setup secure connection between issuer and holder
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
var(issuerCredential, holderCredential) = await Scenarios.IssueCredentialAsync(
_schemaService, _credentialService, _messages, issuerConnection,
holderConnection, _issuerWallet, _holderWallet, await _holderWallet.Pool, TestConstants.DefaultMasterSecret, false, new List <CredentialPreviewAttribute>
{
new CredentialPreviewAttribute("first_name", "Test"),
new CredentialPreviewAttribute("last_name", "Test"),
new CredentialPreviewAttribute("salary", "100000"),
new CredentialPreviewAttribute("age", "25"),
new CredentialPreviewAttribute("wellbeing", "100")
});
Assert.Equal(issuerCredential.State, holderCredential.State);
Assert.Equal(CredentialState.Issued, issuerCredential.State);
var(message, record) = await _proofService.CreateProposalAsync(_holderWallet, new ProofProposal
{
Comment = "Hello, World",
ProposedAttributes = new List <ProposedAttribute>
{
new ProposedAttribute
{
Name = "first_name",
CredentialDefinitionId = holderCredential.CredentialDefinitionId,
Referent = "Proof of Name",
Value = "Joe"
},
new ProposedAttribute
{
Name = "last_name",
CredentialDefinitionId = holderCredential.CredentialDefinitionId,
Referent = "Proof of Name",
Value = "Shmoe"
},
new ProposedAttribute
{
Name = "age",
CredentialDefinitionId = holderCredential.CredentialDefinitionId,
Referent = "Proof of Age",
Value = "Shmoe"
}
},
ProposedPredicates = new List <ProposedPredicate>
{
new ProposedPredicate
{
Name = "salary",
CredentialDefinitionId = holderCredential.CredentialDefinitionId,
Predicate = ">",
Threshold = 99999,
Referent = "Proof of Salary > $99,999"
},
new ProposedPredicate
{
Name = "wellbeing",
CredentialDefinitionId = holderCredential.CredentialDefinitionId,
Referent = "Proof of Wellbeing",
Predicate = "<",
Threshold = 99999
}
}
}, holderConnection.Id);
Assert.NotNull(message);
// Process Proposal
record = await _proofService.ProcessProposalAsync(_issuerWallet, message, issuerConnection);
//
RequestPresentationMessage requestMessage;
(requestMessage, record) = await _proofService.CreateRequestFromProposalAsync(_issuerWallet, new ProofRequestParameters
{
Name = "Test",
Version = "1.0",
NonRevoked = null
}, record.Id, issuerConnection.Id);
Assert.NotNull(requestMessage);
Assert.NotNull(record);
var actualProofRequest = record.RequestJson.ToObject <ProofRequest>();
var expectedProofRequest = new ProofRequest
{
Name = "Test",
Version = "1.0",
Nonce = actualProofRequest.Nonce,
RequestedAttributes = new Dictionary <string, ProofAttributeInfo>
{
{
"Proof of Name", new ProofAttributeInfo
{
Name = null,
Names = new string[] { "first_name", "last_name" },
NonRevoked = null,
Restrictions = new List <AttributeFilter>
{
new AttributeFilter
{
CredentialDefinitionId = holderCredential.CredentialDefinitionId
}
}
}
},
{
"Proof of Age", new ProofAttributeInfo
{
Name = "age",
Names = null,
NonRevoked = null,
Restrictions = new List <AttributeFilter>
{
new AttributeFilter
{
CredentialDefinitionId = holderCredential.CredentialDefinitionId
}
}
}
}
},
RequestedPredicates = new Dictionary <string, ProofPredicateInfo>
{
{
"Proof of Salary > $99,999", new ProofPredicateInfo
{
Name = "salary",
Names = null,
NonRevoked = null,
PredicateType = ">",
PredicateValue = 99999,
Restrictions = new List <AttributeFilter>
{
new AttributeFilter
{
CredentialDefinitionId = holderCredential.CredentialDefinitionId
}
}
}
},
{
"Proof of Wellbeing", new ProofPredicateInfo
{
Name = "wellbeing",
Names = null,
NonRevoked = null,
PredicateType = "<",
PredicateValue = 99999,
Restrictions = new List <AttributeFilter>
{
new AttributeFilter
{
CredentialDefinitionId = holderCredential.CredentialDefinitionId
}
}
}
}
}
};
var expectedProofRecord = new ProofRecord
{
State = ProofState.Requested,
RequestJson = expectedProofRequest.ToJson(),
};
actualProofRequest.Should().BeEquivalentTo(expectedProofRequest);
}
public PagePlayScenario()
{
InitializeComponent();
popUpSplash = new Popup();
popUpSplash.Child = UICreator.CreateSplashWindow();
popUpSplash.Placement = PlacementMode.Center;
popUpSplash.PlacementTarget = PageNavigator.MainWindow;
popUpSplash.IsOpen = false;
StackPanel panelContent = new StackPanel();
panelContent.Margin = new Thickness(10, 0, 10, 0);
panelContent.HorizontalAlignment = System.Windows.HorizontalAlignment.Center;
WrapPanel panelScenarios = new WrapPanel();
panelContent.Children.Add(panelScenarios);
StackPanel panelSelectScenarios = new StackPanel();
panelScenarios.Children.Add(panelSelectScenarios);
TextBlock txtHeader = new TextBlock();
txtHeader.Width = 200;
txtHeader.SetResourceReference(TextBlock.BackgroundProperty, "HeaderBackgroundBrush2");
txtHeader.FontWeight = FontWeights.Bold;
txtHeader.Uid = "1001";
txtHeader.TextAlignment = TextAlignment.Center;
txtHeader.Text = Translator.GetInstance().GetString("PagePlayScenario", txtHeader.Uid);
panelSelectScenarios.Children.Add(txtHeader);
ListBox lbScenarios = new ListBox();
lbScenarios.ItemContainerStyleSelector = new ListBoxItemStyleSelector();
lbScenarios.Height = GraphicsHelpers.GetContentHeight() / 2;
lbScenarios.ItemTemplate = this.Resources["ScenarioItem"] as DataTemplate;
lbScenarios.Width = 200;
foreach (Scenario scenario in Scenarios.GetScenarios())
{
lbScenarios.Items.Add(scenario);
}
panelSelectScenarios.Children.Add(lbScenarios);
panelScenarios.Children.Add(createScenarioPanel());
Button btnExit = new Button();
btnExit.SetResourceReference(Button.StyleProperty, "RoundedButton");
btnExit.Height = double.NaN;
btnExit.Width = double.NaN;
btnExit.Uid = "200";
btnExit.Content = Translator.GetInstance().GetString("PagePlayScenario", btnExit.Uid);
btnExit.Margin = new Thickness(0, 10, 0, 0);
btnExit.Click += btnExit_Click;
btnExit.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
btnExit.SetResourceReference(Button.BackgroundProperty, "ButtonBrush");
panelContent.Children.Add(btnExit);
base.setTopMenu(new PageTopMenu());
base.hideNavigator();
base.hideBottomMenu();
base.setContent(panelContent);
base.setHeaderContent(Translator.GetInstance().GetString("PagePlayScenario", "1000"));
showPage(this);
}
public async Task CreateProofProposalSuccesfully()
{
var proposedAttributes = new List <ProposedAttribute>
{
new ProposedAttribute
{
Name = "first_name",
CredentialDefinitionId = "1",
SchemaId = "1",
IssuerDid = "1",
Referent = "Proof of Name",
Value = "Joe"
},
new ProposedAttribute
{
Name = "second_name",
CredentialDefinitionId = "1",
SchemaId = "1",
IssuerDid = "1",
Referent = "Proof of Name",
Value = "Joe"
},
new ProposedAttribute
{
Name = "age",
CredentialDefinitionId = "1",
SchemaId = "1",
IssuerDid = "1",
Referent = "Proof of Age",
Value = "Joe"
}
};
var proposedPredicates =
new List <ProposedPredicate>
{
new ProposedPredicate
{
Name = "salary",
CredentialDefinitionId = "1",
Predicate = ">",
Threshold = 99999,
Referent = "Proof of Salary > $99,999"
},
new ProposedPredicate
{
Name = "test",
CredentialDefinitionId = "1",
Predicate = ">",
Threshold = 99999,
Referent = "Proof of Test > $99,999"
}
};
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
var proofProposal = new ProofProposal
{
Comment = "Hello, World",
ProposedAttributes = proposedAttributes,
ProposedPredicates = proposedPredicates
};
var(message, record) = await _proofService.CreateProposalAsync(_holderWallet, proofProposal, holderConnection.Id);
var expectedMessage = new ProposePresentationMessage
{
Id = message.Id,
Comment = "Hello, World",
PresentationPreviewMessage = new PresentationPreviewMessage
{
Id = message.PresentationPreviewMessage.Id,
ProposedAttributes = proposedAttributes.ToArray(),
ProposedPredicates = proposedPredicates.ToArray()
}
};
message.Should().BeEquivalentTo(expectedMessage);
}
public List <ScenarioResult> ScenariosByStatus(ExecutionStatus status)
{
return(Scenarios.Where(s => s.Status == status).ToList());
}
public async Task CreateProofProposalThrowsInvalidParameterFormat()
{
// Setup secure connection between issuer and holder
var(issuerConnection, holderConnection) = await Scenarios.EstablishConnectionAsync(
_connectionService, _messages, _issuerWallet, _holderWallet);
var proofProposal = new ProofProposal
{
Comment = "Hello, World",
ProposedAttributes = new List <ProposedAttribute>
{
new ProposedAttribute
{
Name = "first_name",
CredentialDefinitionId = "1",
SchemaId = "1",
IssuerDid = "1",
Referent = "Proof of First Name",
Value = "Joe"
},
new ProposedAttribute
{
Name = "second_name",
CredentialDefinitionId = "2",
SchemaId = "2",
IssuerDid = "2",
Referent = "Proof of First Name",
Value = "Joe"
}
},
ProposedPredicates = new List <ProposedPredicate>
{
new ProposedPredicate
{
Name = "salary",
CredentialDefinitionId = "1",
Predicate = ">",
Threshold = 99999,
Referent = "Proof of Salary > $99,999"
}
}
};
var ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() =>
await _proofService.CreateProposalAsync(_holderWallet, proofProposal, holderConnection.Id));
Assert.True(ex.ErrorCode == ErrorCode.InvalidParameterFormat);
var len = proofProposal.ProposedAttributes.Count - 1;
proofProposal.ProposedAttributes.Remove(proofProposal.ProposedAttributes[len]);
proofProposal.ProposedPredicates.Add(new ProposedPredicate
{
Name = "name",
CredentialDefinitionId = "2",
Predicate = ">",
Threshold = 99999,
Referent = "Proof of Salary > $99,999"
});
ex = await Assert.ThrowsAsync <AriesFrameworkException>(async() =>
await _proofService.CreateProposalAsync(_holderWallet, proofProposal, holderConnection.Id));
Assert.True(ex.ErrorCode == ErrorCode.InvalidParameterFormat);
}
public StoryTests() :
base(Scenarios.OfStories(eventStore => Stories.OfUseCases(
new CustomerUseCases(new Repository <Customer.State>(eventStore))
)))
{
}
public ShellbagScenarioViewModel(Shellbag shellbag) : base()
{
DisplayName = "Shellbags";
Scenarios.Add(shellbag);
}
public void Add(Scenarios.TransmissionLoss transmissionLoss, double bearing)
{
var geoRect = (GeoRect)transmissionLoss.AnalysisPoint.Scenario.Location.GeoRect;
var segment = new GeoSegment(transmissionLoss.AnalysisPoint.Geo, transmissionLoss.Modes[0].MaxPropagationRadius, bearing);
if (!geoRect.Contains(segment[0]) || !geoRect.Contains(segment[1]))
{
//radial.Errors.Add("This radial extends beyond the location boundaries");
return;
}
//Debug.WriteLine("{0}: Queueing calculation of transmission loss for radial bearing {1} degrees, of mode {2} in analysis point {3}", DateTime.Now, radial.Bearing, radial.TransmissionLoss.Mode.ModeName, (Geo)radial.TransmissionLoss.AnalysisPoint.Geo);
Radial outRadial;
if (WorkQueue.TryGetValue(radial.Guid, out outRadial)) return;
WorkQueue.Add(radial.Guid, radial);
_calculatorQueue.Post(radial);
}
internal static DotNetOpenId.RelyingParty.IAuthenticationRequest CreateRelyingPartyRequest(bool stateless, Scenarios scenario, ProtocolVersion version)
{
// Publish RP discovery information
MockHttpRequest.RegisterMockRPDiscovery();
var rp = TestSupport.CreateRelyingParty(stateless ? null : RelyingPartyStore, null);
var rpReq = rp.CreateRequest(TestSupport.GetMockIdentifier(scenario, version), Realm, ReturnTo);
{
// Sidetrack: verify URLs and other default properties
Assert.AreEqual(AuthenticationRequestMode.Setup, rpReq.Mode);
Assert.AreEqual(Realm, rpReq.Realm);
Assert.AreEqual(ReturnTo, rpReq.ReturnToUrl);
}
return rpReq;
}
