/// <summary>
/// Instantiates the extended Test Case class and passes it the SpiraTest Test Case ID
/// </summary>
/// <param name="test">The NUnit Test</param>
/// <param name="member">The method whose attribute we need to read</param>
/// <returns></returns>
public Test Decorate(Test test, System.Reflection.MemberInfo member)
{
const string METHOD_NAME = "Decorate: ";
try
{
if (test is TestMethod)
{
Attribute attribute = Reflect.GetAttribute(member, "Inflectra.SpiraTest.AddOns.SpiraTestNUnitAddIn.SpiraTestFramework.SpiraTestCaseAttribute", false);
if (attribute != null)
{
//Get the test case id from the test case attribute
int testCaseId = (int)Reflect.GetPropertyValue(attribute, "TestCaseId", BindingFlags.Public | BindingFlags.Instance);
test = new SpiraTestCase((TestMethod)test, testCaseId);
}
}
return(test);
}
catch (Exception exception)
{
//Log error then rethrow
System.Diagnostics.EventLog.WriteEntry(SpiraTestAddin.SOURCE_NAME, CLASS_NAME + METHOD_NAME + exception.Message, System.Diagnostics.EventLogEntryType.Error);
throw exception;
}
}
public DebuggerTestSuite(Type type)
: base(type)
{
this.Type = type;
this.Attribute = (DebuggerTestFixtureAttribute)Reflect.GetAttribute(
type, DebuggerTestAddIn.DebuggerTestFixtureAttribute, false);
}
/// <summary>
/// Examine the a Test and either return it as is, modify it
/// or return a different TestCase.
/// </summary>
/// <param name="test">The Test to be decorated</param>
/// <param name="member">The MethodInfo used to construct the test</param>
/// <returns>The resulting Test</returns>
public Test Decorate(Test test, System.Reflection.MemberInfo member)
{
var attr = Reflect.GetAttribute(member, "SymformNUnitExtension.InconclusiveTestAttribute", false);
if (attr == null)
{
return(test);
}
var nunitTest = test as NUnitTestMethod;
if (nunitTest != null)
{
return(new InconclusiveTestCase(nunitTest));
}
var paramTests = test as ParameterizedMethodSuite;
if (paramTests != null)
{
Decorate(paramTests);
}
return(test);
}
public Test Decorate(Test test, MemberInfo member)
{
if (member == null)
{
return(test);
}
TestCase testCase = test as TestCase;
if (testCase == null)
{
return(test);
}
Attribute repeatAttr = Reflect.GetAttribute(member, RepeatAttributeType, true);
if (repeatAttr == null)
{
return(test);
}
object propVal = Reflect.GetPropertyValue(repeatAttr, "Count",
BindingFlags.Public | BindingFlags.Instance);
if (propVal == null)
{
return(test);
}
int count = (int)propVal;
return(new RepeatedTestCase(testCase, count));
}
public void GetAttribute()
{
Assert.IsNull(Reflect.GetAttribute(myType, "Colors.RedAttribute", false), "Red");
Assert.AreEqual("GreenAttribute",
Reflect.GetAttribute(myType, "Colors.GreenAttribute", false).GetType().Name);
Assert.IsNull(Reflect.GetAttribute(myType, "Colors.BlueAttribute", false), "Blue");
}
private string[] GetScripts(Type fixtureType)
{
var scripts = new List <string>();
Attribute fixtureAttribute = Reflect.GetAttribute(fixtureType,
"IronPythonTest.Framework.PythonFixtureAttribute",
true);
Attribute[] scriptAttributes = Reflect.GetAttributes(fixtureType,
"IronPythonTest.Framework.ScriptAttribute",
true);
if (scriptAttributes != null)
{
scripts.AddRange(scriptAttributes.Select(attr => (string)Reflect.GetPropertyValue(attr, "FileName")));
}
var discoverEmbeddedResources =
(bool)Reflect.GetPropertyValue(fixtureAttribute, "DiscoverEmbeddedResources");
if (discoverEmbeddedResources)
{
var discoveryKey = (string)Reflect.GetPropertyValue(fixtureAttribute, "DiscoveryKey");
scripts.AddRange(FindSuitablePythonScripts(fixtureType.Assembly, discoveryKey));
}
return(scripts.ToArray());
}
/// <summary>
/// Initializes an instance of this class.
/// </summary>
/// <remarks>
/// This constructor creates the root test suite.
/// </remarks>
/// <param name="fixtureType">The type of the test fixture.</param>
public BrowserStackFixture(Type fixtureType) : base(fixtureType)
{
BrowserStackFixtureAttribute attr = (BrowserStackFixtureAttribute)Reflect.GetAttribute(fixtureType, typeof(BrowserStackFixtureAttribute).FullName, true);
this.Fixture = Reflect.Construct(fixtureType);
MethodInfo method = Reflect.GetNamedMethod(fixtureType, attr.Argument);
Params = (List <string>)method.Invoke(null, null);
foreach (string param in Params)
{
this.Add(new BrowserStackFixture(fixtureType, param));
}
}
public Test Decorate(Test test, MemberInfo member)
{
NUnitTestMethod testMethod = test as NUnitTestMethod;
if (testMethod != null && testMethod.RunState == RunState.Runnable)
{
List <Attribute> ignoreAttributes = new List <Attribute>();
Attribute[] ignoreAttr = Reflect.GetAttributes(member, IgnoreBrowserAttributeTypeFullName, true);
if (ignoreAttr != null)
{
ignoreAttributes.AddRange(ignoreAttr);
}
Attribute[] ignoreClassAttributes = Reflect.GetAttributes(member.DeclaringType, IgnoreBrowserAttributeTypeFullName, true);
if (ignoreClassAttributes != null)
{
ignoreAttributes.AddRange(ignoreClassAttributes);
}
foreach (Attribute attr in ignoreAttributes)
{
IgnoreBrowserAttribute browserToIgnoreAttr = attr as IgnoreBrowserAttribute;
if (browserToIgnoreAttr != null && IgnoreTestForBrowser(browserToIgnoreAttr.Value))
{
string ignoreReason = "Ignoring browser " + EnvironmentManager.Instance.Browser.ToString() + ".";
if (!string.IsNullOrEmpty(browserToIgnoreAttr.Reason))
{
ignoreReason = ignoreReason + " " + browserToIgnoreAttr.Reason;
}
test.RunState = RunState.Ignored;
test.IgnoreReason = ignoreReason;
}
}
if (test.RunState == RunState.Runnable)
{
NeedsFreshDriverAttribute needsDriverAttr = Reflect.GetAttribute(member, NeedsFreshDriverAttributeTypeFullName, false) as NeedsFreshDriverAttribute;
if (needsDriverAttr != null)
{
test = new WebDriverTestMethod(testMethod, needsDriverAttr.BeforeTest, needsDriverAttr.AfterTest);
}
}
}
return(test);
}
public Test Decorate(Test test, System.Reflection.MemberInfo member)
{
if (test is NUnitTestMethod)
{
Attribute attr = Reflect.GetAttribute(
member, "NUnit.Framework.Extensions.MaxTimeAttribute", false);
if (attr != null)
{
int maxTime = (int)Reflect.GetPropertyValue(attr, "MaxTime", BindingFlags.Public | BindingFlags.Instance);
bool expectFailure = (bool)Reflect.GetPropertyValue(attr, "ExpectFailure", BindingFlags.Public | BindingFlags.Instance);
test = new MaxTimeTestCase((NUnitTestMethod)test, maxTime, expectFailure);
}
}
return(test);
}
public override void OnAuthorization(AuthorizationContext filterContext)
{
base.OnAuthorization(filterContext);
if (HttpContext.Current.User.Identity.IsAuthenticated)
{
var typeController = filterContext.Controller.GetType();
var actionMethodInfo = filterContext.ActionDescriptor;
var passController = Reflect.GetAttribute <AuthorizationPassAttribute>(typeController);
var passAction = actionMethodInfo.Attribute <AuthorizationPassAttribute>();
var passControllerIsValid = true;
var passActionIsValid = true;
if (passController != null)
{
passControllerIsValid = AuthorizationHelper.Validate(passController.Roles);
}
if (passAction != null)
{
passActionIsValid = AuthorizationHelper.Validate(passAction.Roles);
}
if (!(passActionIsValid && passControllerIsValid))
{
HandleUnauthorizedInfo model = null;
if (!passControllerIsValid)
{
model = new HandleUnauthorizedInfo();
}
else
{
model = new HandleUnauthorizedInfo();
}
filterContext.Result = new ViewResult
{
ViewName = "Unauthorized",
TempData = filterContext.Controller.TempData,
ViewData = new ViewDataDictionary <HandleUnauthorizedInfo>(model),
};
filterContext.HttpContext.Response.Clear();
filterContext.HttpContext.Response.StatusCode = 500;
}
}
}
public Test Decorate(Test test, MemberInfo member)
{
Attribute attr = Reflect.GetAttribute(member, "NUnit.Framework.MultiCultureAttribute", true);
if (attr == null)
{
return(test);
}
string cultures = Reflect.GetPropertyValue(attr, "Cultures") as string;
if (cultures == null)
{
return(test);
}
return(new MultiCultureTestSuite(test, cultures));
}
public IEnumerable GetDataFor(ParameterInfo parameter)
{
Attribute attr = Reflect.GetAttribute(parameter, ParameterDataAttribute, false);
if (attr == null)
{
return(null);
}
MethodInfo getData = attr.GetType().GetMethod(
GetDataMethod,
new Type[] { typeof(ParameterInfo) });
if (getData == null)
{
return(null);
}
return(getData.Invoke(attr, new object[] { parameter }) as IEnumerable);
}
static public void Apply(object inObject, UnityEngine.Object inHost = null)
{
if (inObject == null)
{
return;
}
Type objType = inObject.GetType();
bool bChanged = false;
foreach (var field in objType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
{
if (!field.IsPublic && !field.IsDefined(typeof(SerializeField)))
{
continue;
}
DefaultAssetAttribute defaultAssetAttr = Reflect.GetAttribute <DefaultAssetAttribute>(field);
if (defaultAssetAttr != null)
{
Type type = field.FieldType;
string name = defaultAssetAttr.AssetName;
UnityEngine.Object asset = (UnityEngine.Object)field.GetValue(inObject);
if (asset == null)
{
asset = AssetDBUtils.FindAsset(type, name);
if (asset != null)
{
field.SetValue(inObject, asset);
bChanged = true;
}
}
}
}
if (bChanged && inHost)
{
EditorUtility.SetDirty(inHost);
}
}
public override void OnAuthorization(HttpActionContext actionContext)
{
var typeController = actionContext.ControllerContext.Controller.GetType();
var actionMethodInfo = actionContext.ActionDescriptor;
var allowAnonymousController = Reflect.GetAttribute <AllowAnonymousAttribute>(typeController);
var allowAnonymousAction = actionMethodInfo.GetCustomAttributes <AllowAnonymousAttribute>().FirstOrDefault();
ExecutionContext.SetObject("isLogged", 0);
if (allowAnonymousAction == null)
{
var token = actionContext.Request.Headers.GetValues("token").FirstOrDefault();
int userId = 0;
int.TryParse(actionContext.Request.Headers.GetValues("user").FirstOrDefault(), out userId);
if (!AuthorizationHelper.ValidateToken(userId, token))
{
actionContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);
}
ExecutionContext.SetObject("isLogged", userId);
}
}
public Test BuildFrom(Type type)
{
var suite = new ParameterizedFixtureSuite(type);
var attr = (ParameterizedTestFixtureAttribute)Reflect.GetAttribute(type, typeof(ParameterizedTestFixtureAttribute).FullName, true);
ITestParameterProvider provider;
if (attr.FactoryName != null)
{
provider = Configuration.GetProvider(attr.FactoryName);
}
else
{
provider = Configuration.GetProvider(attr.Type);
}
foreach (var parameter in provider.GetParameters(type))
{
suite.Add(BuildFixture(type, attr, parameter));
}
return(suite);
}
/// <summary>
/// Executes the NUnit test case
/// </summary>
/// <returns>The test result</returns>
public override TestResult RunTest()
{
const string METHOD_NAME = "RunTest: ";
try
{
//Call the base method to run the result within NUnit
TestResult result = base.RunTest();
//Get the URL, Login, Password and ProjectId from the parent test fixture attribute
Type type = testMethod.FixtureType;
Attribute attribute = Reflect.GetAttribute(type, "Inflectra.SpiraTest.AddOns.SpiraTestNUnitAddIn.SpiraTestFramework.SpiraTestConfigurationAttribute", false);
if (attribute == null)
{
throw new Exception("Cannot retrieve the SpiraTestConfiguration attribute from the test fixture");
}
//Get the various properties from the attribute
string url = (string)Reflect.GetPropertyValue(attribute, "Url", BindingFlags.Public | BindingFlags.Instance);
string login = (string)Reflect.GetPropertyValue(attribute, "Login", BindingFlags.Public | BindingFlags.Instance);
string password = (string)Reflect.GetPropertyValue(attribute, "Password", BindingFlags.Public | BindingFlags.Instance);
int projectId = (int)Reflect.GetPropertyValue(attribute, "ProjectId", BindingFlags.Public | BindingFlags.Instance);
Nullable <int> releaseId = null;
if (Reflect.GetPropertyValue(attribute, "ReleaseId", BindingFlags.Public | BindingFlags.Instance) != null)
{
releaseId = (Nullable <int>)Reflect.GetPropertyValue(attribute, "ReleaseId", BindingFlags.Public | BindingFlags.Instance);
}
Nullable <int> testSetId = null;
if (Reflect.GetPropertyValue(attribute, "TestSetId", BindingFlags.Public | BindingFlags.Instance) != null)
{
testSetId = (Nullable <int>)Reflect.GetPropertyValue(attribute, "TestSetId", BindingFlags.Public | BindingFlags.Instance);
}
string runnerName = Reflect.GetPropertyValue(attribute, "Runner", BindingFlags.Public | BindingFlags.Instance).ToString();
//Now we need to extract the result information
int executionStatusId = -1;
if (!result.Executed)
{
//Set status to 'Not Run'
executionStatusId = 3;
}
else
{
//If no codes are found, default to blocked;
executionStatusId = 5;
if (result.IsFailure)
{
//Set status to 'Failed'
executionStatusId = 1;
}
if (result.IsSuccess)
{
//Set status to 'Passed'
executionStatusId = 2;
}
if (result.IsError)
{
//Set status to 'Failed'
executionStatusId = 1;
}
}
//Extract the other information
string testCaseName = result.Name;
string message = result.Message;
string stackTrace = result.StackTrace;
int assertCount = result.AssertCount;
DateTime startDate = DateTime.Now.AddSeconds(-result.Time);
DateTime endDate = DateTime.Now;
//Specify that we will be using TLS 1.2 if this is HTTPS
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
//Instantiate the web-service proxy class and set the URL from the text box
bool success = false;
SpiraImportExport.ImportExport spiraTestExecuteProxy = new SpiraImportExport.ImportExport();
spiraTestExecuteProxy.Url = url + TEST_EXECUTE_WEB_SERVICES_URL;
//Create a new cookie container to hold the session handle
CookieContainer cookieContainer = new CookieContainer();
spiraTestExecuteProxy.CookieContainer = cookieContainer;
//Attempt to authenticate the user
success = spiraTestExecuteProxy.Connection_Authenticate(login, password);
if (!success)
{
throw new Exception("Cannot authenticate with SpiraTest, check the URL, login and password");
}
//Now connect to the specified project
success = spiraTestExecuteProxy.Connection_ConnectToProject(projectId);
if (!success)
{
throw new Exception("Cannot connect to the specified project, check permissions of user!");
}
//Now actually record the test run itself
SpiraImportExport.RemoteTestRun remoteTestRun = new SpiraImportExport.RemoteTestRun();
remoteTestRun.TestCaseId = testCaseId;
remoteTestRun.ReleaseId = releaseId;
remoteTestRun.TestSetId = testSetId;
remoteTestRun.StartDate = startDate;
remoteTestRun.EndDate = endDate;
remoteTestRun.ExecutionStatusId = executionStatusId;
remoteTestRun.RunnerName = runnerName;
remoteTestRun.RunnerTestName = testCaseName;
remoteTestRun.RunnerAssertCount = assertCount;
remoteTestRun.RunnerMessage = message;
remoteTestRun.RunnerStackTrace = stackTrace;
spiraTestExecuteProxy.TestRun_RecordAutomated1(remoteTestRun);
//Close the SpiraTest connection
spiraTestExecuteProxy.Connection_Disconnect();
//Return the result
return(result);
}
catch (Exception exception)
{
//Log error then rethrow (catch any errors associated with the diagnostics)
try
{
System.Diagnostics.EventLog.WriteEntry(SpiraTestAddin.SOURCE_NAME, CLASS_NAME + METHOD_NAME + exception.Message, System.Diagnostics.EventLogEntryType.Error);
}
catch {}
throw exception;
}
}
public static bool Validate <T>() where T : class
{
var pass = Reflect.GetAttribute <AuthorizationPassAttribute>(typeof(T));
return(pass != null?Validate(pass.Roles) : true);
}