public void SingleQueueControllerTest()
{
var manager = new QueueMessageManagerSql();
// sample - create 3 message
for (int i = 0; i < 3; i++)
{
var item = new QueueMessageItem()
{
QueueName = "Queue1",
Message = "Print Image",
Action = "PRINTIMAGE",
TextInput = "4334333" // image Id
};
// sets appropriate settings for submit on item
manager.SubmitRequest(item);
// item has to be saved
Assert.IsTrue(manager.Save(), manager.ErrorMessage);
Console.WriteLine("added " + manager.Item.Id);
}
Console.WriteLine("Starting... Async Manager Processing");
// create a new Controller to process in the background
// on separate threads
var controller = new QueueController()
{
ConnectionString = "QueueMessageManager",
ThreadCount = 2,
WaitInterval = 200,
QueueName = "Queue1"
};
Console.WriteLine("Wait: " + controller.WaitInterval);
// ExecuteStart Event is where your processing logic goes
controller.ExecuteStart += controller_ExecuteStart;
// ExecuteFailed and ExecuteComplete let you take actions on completion
controller.ExecuteComplete += controller_ExecuteComplete;
controller.ExecuteFailed += controller_ExecuteFailed;
// actually start the queue
controller.StartProcessingAsync();
// For test we have to keep the threads alive
// to allow the 3 requests to process
Thread.Sleep(2000);
// shut down
controller.StopProcessing();
Thread.Sleep(200);
Console.WriteLine("Stopping... Async Manager Processing");
Assert.IsTrue(true);
}
public QueueController_unitTest()
{
QueueRepositoryMock = new Mock <IQueueRepository>();
UnitofWorkMock = new Mock <IUnitOfWork>();
MapperMock = new Mock <IMapper>();
_uut = new QueueController(UnitofWorkMock.Object, MapperMock.Object);
}
public void GenerateTestData()
{
const int count = 10000;
try
{
var controller = new QueueController();
string id = string.Empty;
string format = string.Empty;
for (int i = 0; i < count.ToString().Length; i++)
{
format = format + "0";
}
for (int i = 1; i <= count; i++)
{
Task.Delay(1);
id = TestIdprefix + i.ToString(format);
controller.Put(id, new Queue()
{
ParkingCard = id
});
}
Assert.IsNotNull(controller.Get(id));
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
// global instances that keep controller and windows service alive
public void Start(QueueMessageManager manager = null)
{
if (manager == null)
{
manager = new QueueMessageManagerSql();
}
LogManager.Current.LogInfo("Start called");
var config = QueueMessageManagerConfiguration.Current;
Controller = new QueueController()
{
ConnectionString = config.ConnectionString,
QueueName = config.QueueName,
WaitInterval = config.WaitInterval,
ThreadCount = config.ControllerThreads
};
LogManager.Current.LogInfo("Controller created.");
// asynchronously start the SignalR hub
SignalR = WebApplication.Start <SignalRStartup>("http://*:8080/");
// *** Spin up n Number of threads to process requests
Controller.StartProcessingAsync();
LogManager.Current.LogInfo(String.Format("QueueManager Controller Started with {0} threads.",
Controller.ThreadCount));
// Set static instances so that these 'services' stick around
GlobalService.Controller = Controller;
GlobalService.Service = this;
}
public void Test_Post_Success()
{
QueueController ctrl = new QueueController(new QueueShardRepository(new List <QueueShard <IQueueShardItem> >()));
var result = ctrl.Post("newQueue");
var model = Assert.IsType <OkObjectResult>(result);
Assert.Contains("newQueue", model.Value.ToString());
}
public void Test_Get_EmptyQueueList()
{
QueueController ctrl = new QueueController(new QueueShardRepository(new List <QueueShard <IQueueShardItem> >()));
var result = ctrl.Get();
var model = Assert.IsType <OkObjectResult>(result);
var collection = Assert.IsAssignableFrom <IEnumerable <string> >(model.Value);
Assert.Empty(collection);
}
public void Test_Put_NullItem()
{
QueueController ctrl = new QueueController(new QueueShardRepository(new List <QueueShard <IQueueShardItem> >()
{
new QueueShard <IQueueShardItem>("test0")
}));
var result = ctrl.Put("test0", null);
Assert.IsType <BadRequestObjectResult>(result);
}
public void Test_Put_NullQueue()
{
QueueController ctrl = new QueueController(new QueueShardRepository());
byte[] value = new byte[50];
new Random().NextBytes(value);
var result = ctrl.Put(null, Convert.ToBase64String(value));
Assert.IsType <BadRequestObjectResult>(result);
}
public void Test_Delete_Success()
{
QueueController ctrl = new QueueController(new QueueShardRepository(new List <QueueShard <IQueueShardItem> >()
{
new QueueShard <IQueueShardItem>("test0")
}));
var result = ctrl.Delete("test0");
var model = Assert.IsType <OkObjectResult>(result);
Assert.Equal("test0", model.Value);
}
public void QueueControllerTimerTest()
{
try
{
var controller = new QueueController();
var result = controller.Post(start: true);
//Assert.IsNotNull(result);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void QueueControllerRotationTest()
{
try
{
var controller = new QueueController();
var result = controller.Post(rotation: 1);
//Assert.IsNotNull(result);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void IsPlaying_Set_EventNotCalled()
{
var eventRaised = false;
IQueueController controller = new QueueController();
controller.IsPlayingChangedEvent += delegate(object sender, PlayingChangedEventArgs status)
{
eventRaised = true;
};
controller.IsPlaying = false;
Assert.AreEqual(eventRaised, false);
}
public void QueueControllerGetByIdTest()
{
try
{
var controller = new QueueController();
string id = GetRandomId(1000);
var result = controller.Get(id);
//Assert.IsNotNull(result);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void Test_Put_Success()
{
QueueController ctrl = new QueueController(new QueueShardRepository(new List <QueueShard <IQueueShardItem> >()
{
new QueueShard <IQueueShardItem>("test0")
}));
byte[] value = new byte[50];
new Random().NextBytes(value);
var result = ctrl.Put("test0", Convert.ToBase64String(value));
var model = Assert.IsType <OkObjectResult>(result);
Assert.IsType <string>(model.Value);
}
public void QueueControllerDeleteTest()
{
try
{
string id = GetRandomId(1000);
var controller = new QueueController();
//string id = controller.Get().Skip(randomId).First().ParkingCard;
var result = controller.Delete(id, OutputReasonEnum.Vip);
//Assert.IsNull(controller.Get(id));
Assert.IsTrue(true);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void CurrentSong_set_NewRaiseEvent()
{
var eventRaised = false;
BaseSong songSent = null;
IQueueController controller = new QueueController();
controller.CurrentSongChangedEvent += delegate(object s, SongChangedEventArgs model)
{
eventRaised = true;
songSent = model.CurrentSong;
};
var songStub = new TestSong();
controller.CurrentSong = songStub;
Assert.IsTrue(eventRaised);
Assert.AreSame(songSent, songStub);
}
public async Task PushToQueue_BadModel()
{
// test setup
var controller = new QueueController(_mockService.Object);
controller.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
}
};
controller.ModelState.AddModelError("fakeError", "fakeError");
// mock request
JsonWithResponse response = await controller.PushToQueue(new QueueMessagesPost { QueueName = "da-queue" });
Assert.Equal("Invalid queue request!", response.Message);
}
public void IsPlaying_Set_Event()
{
var eventRaised = false;
bool eventResult = false;
IQueueController controller = new QueueController();
controller.CurrentSong = new TestSong();
controller.IsPlayingChangedEvent += delegate(object sender, PlayingChangedEventArgs status)
{
eventRaised = true;
eventResult = status.IsPlaying;
};
controller.IsPlaying = true;
Assert.AreEqual(eventRaised, true);
Assert.AreEqual(eventResult, true);
}
public void QueueControllerPutTest()
{
try
{
//string id = Guid.NewGuid().ToString().Substring(0, 16);
//string id = "test1";
string id = GetRandomId(1000);
var controller = new QueueController();
var result = controller.Put(id, null);
//Assert.IsNotNull(controller.Get(id));
Assert.IsTrue(true);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public void Initialize()
{
this.createCollection = new Mock <ICommandHandler <CreateQueueCommand> >();
this.updateCollection = new Mock <ICommandHandler <UpdateQueueCommand> >();
this.deleteCollection = new Mock <ICommandHandler <DeleteQueueCommand> >();
this.getLiveDateOfNewQueuedPost = new Mock <IQueryHandler <GetLiveDateOfNewQueuedPostQuery, DateTime> >();
this.requesterContext = new Mock <IRequesterContext>();
this.guidCreator = new Mock <IGuidCreator>();
this.random = new Mock <IRandom>();
this.target = new QueueController(
this.createCollection.Object,
this.updateCollection.Object,
this.deleteCollection.Object,
this.getLiveDateOfNewQueuedPost.Object,
this.requesterContext.Object,
this.guidCreator.Object,
this.random.Object);
}
public QueueControllerTests()
{
// mock the queue service
_mockService = new Mock <IQueueService>();
// TODO: Setup the mocks
_mockService.Setup(x => x.QueueExists("da-queue")).ReturnsAsync(true);
_mockService.Setup(x => x.PullFromQueue("da-queue", true)).ReturnsAsync("a delete message");
_mockService.Setup(x => x.PullFromQueue("da-queue", false)).ReturnsAsync("a pop message");
_mockService.Setup(x => x.PushToQueue("da-queue", new List <string> {
"test"
})).ReturnsAsync(true);
// create the controller
_queueController = new QueueController(_mockService.Object);
_queueController.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
}
};
}
public void SetUp()
{
_scanResultServiceMock = new Mock <IScanResultService>();
_scanResultServiceMock
.Setup(x => x.ObtainFile("existing"))
.Returns(Task.FromResult(new MemoryStream() as Stream));
_scanResultServiceMock
.Setup(x => x.ObtainFile("non-existing"))
.Returns(Task.FromResult((Stream)null));
_scanResultServiceMock
.Setup(x => x.GetScanResult("existing"))
.Returns(Task.FromResult(new ScanResult
{
Id = "existing"
}));
_scanResultServiceMock
.Setup(x => x.GetScanResult("non-existing"))
.Returns(Task.FromResult((ScanResult)null));
_scanResultServiceMock
.Setup(x => x.ObtainFile("non-existing"))
.Returns(Task.FromResult((Stream)null));
_scanResultServiceMock
.Setup(x => x.CreateScanResult(null))
.Returns(Task.FromResult(new ScanResult()));
_downloadController = new DownloadController(_scanResultServiceMock.Object);
_scanResultsController = new ScanResultsController(_scanResultServiceMock.Object);
_queueController = new QueueController(_scanResultServiceMock.Object)
{
Url = Mock.Of <IUrlHelper>()
};
}
public PlaySelectPage()
{
InitializeComponent();
#region Queues
queues = new List <GameQueue> {
//queues[ClassicQueues] = new List<Queue> {
new GameQueue("Teambuilder Draft", 400, null, "Create Group", PlayTBD),
//new GameQueue("Teambuilder", 61, "Enter Soloqueue", "Create Lobby", PlayTeambuilder),
new GameQueue("Blind Pick 5v5", 2, "Enter Soloqueue", "Create Lobby", PlayStandard),
new GameQueue("Draft Pick 5v5", 14, "Enter Soloqueue", "Create Lobby", PlayStandard),
new GameQueue("Blind Pick 3v3", 8, "Enter Soloqueue", "Create Lobby", PlayStandard),
//};
//queues[SpecialQueues] = new List<Queue> {
new GameQueue("Blind Pick Dominion", 16, "Enter Soloqueue", "Create Lobby", PlayStandard),
new GameQueue("Draft Pick Dominion", 17, "Enter Soloqueue", "Create Lobby", PlayStandard),
new GameQueue("ARAM", 65, "Enter Soloqueue", "Create Lobby", PlayStandard),
new GameQueue("King Poro", 300, "Enter Soloqueue", "Create Lobby", PlayStandard),
//};
//queues[RankedQueues] = new List<Queue> {
new GameQueue("Ranked Solo / Duo Queue", 410, null, "Create Group", PlayTBD),
new GameQueue("Ranked Solo / Duo Queue", 4, "Enter Soloqueue", "Invite Duo Partner", PlayRanked),
new GameQueue("Ranked Teams 5v5", 42, null, "Create Lobby", PlayRankedTeams),
new GameQueue("Ranked Teams 3v3", 41, null, "Create Lobby", PlayRankedTeams),
};
#endregion
if (!Session.Installed.GameVersion.Equals(Session.Latest.GameVersion))
{
PatchGrid.Visibility = Visibility.Visible;
}
queueTimer = new QueueController(QueueLabel, ChatStatus.inQueue, ChatStatus.outOfGame);
SummonersRift.Tag = GameMap.SummonersRift;
}
private void Awake()
{
instance = this;
}
