blob: 926c4a573c6b6e6b66bff6a477ab8c5c03d657c1 [file] [log] [blame]
/*
* Copyright 2005 The Apache Software Foundation.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
using System;
using System.Collections;
using System.Text;
using Agility.Core;
using Agility.Extras.Spring;
using Nexus.Core.Helpers;
using NUnit.Framework;
using Spring.Context;
namespace Nexus.Core
{
/// <summary>
/// Provide base SetUp method and convenience methods
/// for tests that use a IRequestCatalog.
/// </summary>
///
[TestFixture]
public class CatalogBaseTest
{
/// <summary>
/// Catalog instance that tests can use.
/// </summary>
protected IRequestCatalog catalog;
/// <summary>
/// Setup catalog between tests.
/// </summary>
///
[SetUp]
public virtual void SetUp()
{
IApplicationContext factory = Objects.Factory();
catalog = factory.GetObject("Catalog") as IRequestCatalog;
}
/// <summary>
/// Exercise Setup method.
/// </summary>
///
[Test]
public void AssertSetUp()
{
Assert.IsTrue(catalog != null, "Expected non-null catalog.");
}
#region IRequestContext tests
/// <summary>
/// Determine if the context contains each key in keys.
/// </summary>
/// <param name="context">Context to process</param>
/// <param name="keys">Keys to verify</param>
/// <returns>True if contact contains each key in keys</returns>
protected bool ContainsKeys(IContext context, string[] keys)
{
bool found = true;
foreach (string key in keys)
{
found = found && context.Contains(key);
}
return found;
}
/// <summary>
/// Determine if the Criteria for context contains each key in keys.
/// </summary>
/// <param name="context">Context to process</param>
/// <param name="keys">Keys to verify</param>
/// <returns>True if Criteria for contact contains each key in keys</returns>
public bool ContainsCriteriaKeys(IRequestContext context, string[] keys)
{
if (!context.HasCriteria()) return false;
IDictionary criteria = context.Criteria;
bool found = true;
foreach (string v in keys)
{
found = found && criteria.Contains(v);
}
return found;
}
protected void FaultText(Exception fault)
{
StringBuilder text = new StringBuilder("[");
text.Append(fault.Message);
text.Append("] ");
text.Append(fault.Source);
text.Append(fault.StackTrace);
Assert.Fail(text.ToString());
}
/// <summary>
/// Convenience method to confirm that no Exception was caught.
/// </summary>
/// <param name="context">Context under test</param>
///
public void AssertNoFault(IRequestContext context)
{
if (context.HasFault)
{
FaultText(context.Fault);
}
}
/// <summary>
/// Convenience method to confirm that no Exception was caught.
/// </summary>
/// <param name="helper">Helper under test</param>
///
public void AssertNoFault(IViewHelper helper )
{
if (helper.HasFault) FaultText(helper.Fault) ;
}
/// <summary>
/// Convenience method to confirm
/// that there are no alerts or fault.
/// </summary>
/// <param name="context">Context under test</param>
///
public void AssertNominal(IRequestContext context)
{
AssertNoFault(context);
bool hasAlerts = context.HasAlerts;
if (hasAlerts)
{
// TODO: Use new TextOnly method here.
StringBuilder outer = new StringBuilder();
IDictionary store = context.Alerts;
ICollection keys = store.Keys;
foreach (string key in keys)
{
StringBuilder inner = new StringBuilder();
inner.Append(key);
inner.Append(": ");
IList messages = store[key] as IList;
foreach (string message in messages)
{
inner.Append(message);
inner.Append(";");
}
outer.Append(inner.ToString());
outer.Append("/n");
}
Assert.Fail(outer.ToString());
}
}
/// <summary>
/// Convenience method to confirm
/// that there are no alerts or fault.
/// </summary>
/// <param name="helper">Helper under test</param>
///
public void AssertNominal(IViewHelper helper)
{
AssertNoFault(helper);
bool hasAlerts = helper.HasAlerts;
if (hasAlerts)
{
Assert.Fail(helper.AlertsText);
}
}
/// <summary>
/// Confirm that the value is stored in the context under the key.
/// </summary>
/// <param name="context">The context to check</param>
/// <param name="key">The key</param>
/// <param name="value">The value</param>
protected void AssertKey(IDictionary context, string key, string value)
{
Assert.IsNotNull(value, "Value is null");
Assert.IsNotNull(key, "Key is null");
Assert.IsTrue(value.Equals(context[key]), "Key:Value mismatch: " + key + ":" + value);
}
/// <summary>
/// Confirm that the given context contains the given keys.
/// </summary>
/// <param name="context">The context to check</param>
/// <param name="keys">The keys to check</param>
protected void AssertKeys(IRequestContext context, string[] keys)
{
Assert.IsTrue(ContainsKeys(context, keys), "Missing keys.");
}
/// <summary>
/// Confirm that the context contains the keys,
/// that each key represents an non-null IList,
/// and that each IList is not empty.
/// </summary>
/// <param name="context">The context to check</param>
/// <param name="keys">The list keys</param>
protected void AssertListKeys(IRequestContext context, string[] keys)
{
AssertKeys(context, keys);
foreach (string key in keys)
{
IList list = context[key] as IList;
Assert.IsNotNull(list, "List is null: " + key);
Assert.IsTrue(list.Count > 0, "List is empty");
}
}
/// <summary>
/// Call AssertList(string,int) with no minimum.
/// </summary>
/// <param name="id"></param>
protected IRequestContext AssertList(string id)
{
return AssertList(id, 0);
}
/// <summary>
/// Execute the Command for the given id,
/// and confirm that the return state is Nominal,
/// has an Outcome,
/// that the Outcome is an non-null IList,
/// and that the IList containes at list minCount items.
/// </summary>
/// <param name="id">The List Command to check</param>
/// <param name="minCount">The minimum number of items</param>
protected IRequestContext AssertList(string id, int minCount)
{
IRequestContext context = catalog.GetRequestContext(id);
catalog.ExecuteRequest(context);
AssertNominal(context);
Assert.IsTrue(context.HasOutcome, "Expected outcome");
IList list = context.Outcome as IList;
Assert.IsNotNull(list, "Expected outcome as IList");
Assert.IsTrue(list.Count >= minCount, "Expected list entries");
return context;
}
#endregion
#region data access tests
/// <summary>
/// Virtual method for populating a context
/// for use with other routine tests.
/// </summary>
/// <param name="context"></param>
protected virtual void Populate(IDictionary context)
{
// override to populate context
throw new NotImplementedException("CatalogBaseTest.Populate must be overridden.");
}
/// <summary>
/// Virtual method for populating a context
/// for an insert test.
/// </summary>
/// <param name="context"></param>
protected virtual void PopulateInsert(IDictionary context)
{
Populate(context);
}
/// <summary>
/// Insert and then delete a new record,
/// calling the Populate method to fill the context with the appropriate values.
/// </summary>
/// <param name="insertId">The "save" command name</param>
/// <param name="keyId">The name of the primary key field</param>
/// <param name="keyValue">The primary key value initially set by Populate</param>
/// <param name="deleteId">The "delete" command name</param>
protected IRequestContext AssertInsertDelete(string insertId, string keyId, string keyValue, string deleteId)
{
IRequestContext context = catalog.GetRequestContext(insertId);
PopulateInsert(context);
context[keyId] = String.Empty;
catalog.ExecuteRequest(context);
AssertNominal(context);
Assert.IsFalse(keyValue.Equals(context[keyId]), "Expected new primary key");
ICommand delete = catalog.GetCommand(deleteId);
delete.Execute(context);
AssertNominal(context);
return context;
}
protected IRequestContext AssertEdit(string editId, string keyId, string keyValue, string[] keys)
{
IRequestContext context = catalog.GetRequestContext(editId);
context[keyId] = keyValue;
catalog.ExecuteRequest(context);
AssertNominal(context);
Assert.IsTrue(ContainsKeys(context, keys), "Missing fields");
return context;
}
/// <summary>
/// Update the given record (usually to the same values).
/// </summary>
/// <param name="updateId">The "save" command</param>
/// <param name="keyId">The name of the primary key</param>
/// <param name="keyValue">The value of the primary key</param>
protected IRequestContext AssertUpdate(string updateId, string keyId, string keyValue)
{
IRequestContext context = catalog.GetRequestContext(updateId);
Populate(context);
catalog.ExecuteRequest(context);
AssertNominal(context);
Assert.IsTrue(keyValue.Equals(context[keyId]));
return context;
}
#endregion
}
}