leonidas 0.0.1

data/spec/jasmine/support/classes.coffee

@@ -0,0 +1,16 @@
+globalize class IncrementHandler
+
+	constructor: (@state)->
+
+	handles: (command)-> command.name is "increment"
+
+	run: (command)-> @state.integer++
+
+
+globalize class PopCharHandler
+
+	constructor: (@state)->
+
+	handles: (command)-> command.name is "pop-char"
+
+	run: (command)-> @state.string = @state.string.slice(0,-1)

data/spec/jasmine/support/helpers.coffee

@@ -0,0 +1,22 @@
+(exports ? this).globalize = (fxn, name=null)=>
+  functionName = if name is null then fxn.name else name
+  (exports ? this)[functionName] = fxn
+
+
+# MOCKING #
+(exports ? this).mocks = {}
+
+(exports ? this).addMock = (name, obj)=>
+  (exports ? this).mocks[name] = obj
+
+
+# RUNTIME PATCHING #
+(exports ? this).patches = {}
+
+(exports ? this).patch = (method, patch)=>
+  (exports ? this).patches[method.name] = method
+  method = patch
+
+(exports ? this).restore = (method)=>
+  method = (exports ? this).patches[method.name]
+  delete (exports ? this).patches[method.name]

data/spec/jasmine/support/mocks.coffee

@@ -0,0 +1,19 @@
+addMock "syncPushResponse",
+	success: true
+	message: 'commands received'
+	data: { }
+
+addMock "syncPullResponse",
+	success: true
+	message: 'commands retrieved'
+	data:
+		commands: [
+			{ name: 'pop-char',  data: { }, timestamp: 2 },
+			{ name: 'increment', data: { }, timestamp: 6 },
+			{ name: 'increment', data: { }, timestamp: 8 }
+		]
+		currentClients: [
+			{ id: "2345", lastUpdate: 2 },
+			{ id: "3456", lastUpdate: 8 }
+		]
+		stableTimestamp: 2

data/spec/jasmine/support/objects.coffee

@@ -0,0 +1,11 @@
+Command = require 'leonidas/commands/command'
+Client = require 'leonidas/client'
+
+buildCommand = (timestamp, name="increment", data={})->
+	new Command(name, data, timestamp)
+
+buildClient = ->
+	new Client("app 1", { integer: 1, string: "test" })
+
+globalize(buildCommand, "buildCommand")
+globalize(buildClient, "buildClient")

data/spec/jasmine/support/requirements.coffee

@@ -0,0 +1 @@
+require "lib/jquery"

data/spec/jasmine/tests/client_spec.coffee

@@ -0,0 +1,20 @@
+Client = require 'leonidas/client'
+
+describe "Client", ->
+	client = null
+
+	beforeEach ->
+		client = new Client("app 1", { test: "test" })
+		client.activeState = { test: "different" }
+
+	describe "#revertState", ->
+
+		it "will revert the active state to the locked state", ->
+			client.revertState()
+			expect(client.activeState).toEqual { test: "test" }
+
+	describe "#lockState", ->
+
+		it "will lock the state to the active state", ->
+			client.lockState()
+			expect(client.lockedState).toEqual { test: "different" }

data/spec/jasmine/tests/commander_spec.coffee

@@ -0,0 +1,69 @@
+Organizer = require "leonidas/commands/organizer"
+Processor = require "leonidas/commands/processor"
+Stabilizer = require "leonidas/commands/stabilizer"
+Synchronizer = require "leonidas/commands/synchronizer"
+Commander = require 'leonidas/commander'
+
+describe "Commander", ->
+	commander = null
+	client = null
+	organizer = null
+	synchronizer = null
+
+	beforeEach ->
+		client = buildClient()
+		organizer = new Organizer()
+		processor = new Processor([ new PopCharHandler(client.activeState) ])
+		stabilizer = new Stabilizer(client, organizer, processor)
+		synchronizer = new Synchronizer("http://mydomain.com/sync", client, organizer, stabilizer)
+		spyOn(synchronizer, "push")
+		spyOn(synchronizer, "pull")
+		commander = new Commander(organizer, processor, stabilizer, synchronizer)
+
+	describe "::default", ->
+
+		it "will return a default commander using the built in classes", ->
+			commander = Commander.default(client, [ new PopCharHandler("tim") ], "http://mydomain.com/sync")
+			expect(commander.constructor).toEqual Commander
+
+	describe "#startSync", ->
+
+		beforeEach -> 
+      jasmine.Clock.useMock()
+
+		it "will set the synchronizer to begin pushing updates", ->
+     	commander.startSync()
+     	jasmine.Clock.tick(5500)
+     	expect(synchronizer.push.calls.length).toEqual 5
+
+		it "will set the synchronizer to begin pulling updates", ->
+     	commander.startSync()
+     	jasmine.Clock.tick(11000)
+     	expect(synchronizer.pull.calls.length).toEqual 2
+
+	describe "#stopSync", ->
+
+		beforeEach -> 
+      jasmine.Clock.useMock()
+
+		it "will stop the synchronizer from pushing updates", ->
+			commander.startSync()
+			commander.stopSync()
+			jasmine.Clock.tick(10000)
+			expect(synchronizer.push).not.toHaveBeenCalled()
+
+		it "will stop the synchronizer from pulling updates", ->
+			commander.startSync()
+			commander.stopSync()
+			jasmine.Clock.tick(10000)
+			expect(synchronizer.pull).not.toHaveBeenCalled()
+
+	describe "#issueCommand", ->
+
+		it "will generate an unsynchronized command", ->
+			commander.issueCommand "pop-char", {}
+			expect(organizer.unsyncedCommands.length).toEqual 1
+
+		it "will run the command to update the local client state", ->
+			commander.issueCommand "pop-char", {}
+			expect(client.activeState.string).toEqual "tes"

data/spec/jasmine/tests/commands/command_spec.coffee

@@ -0,0 +1,12 @@
+Command = require 'leonidas/commands/command'
+
+describe "Command", ->
+	command = null
+
+	beforeEach ->
+		command = new Command("test", { testData: "test" }, 25)
+
+	describe "#toHash", ->
+
+		it "will return the command serialized as a hash", ->
+			expect(command.toHash()).toEqual { name: "test", data: { testData: "test" }, timestamp: 25 }

data/spec/jasmine/tests/commands/organizer_spec.coffee

@@ -0,0 +1,70 @@
+Organizer = require 'leonidas/commands/organizer'
+
+describe "Organizer", ->
+	command1 = command2 = command3 = command4 = null
+	organizer = null
+
+	beforeEach ->
+		command1 = buildCommand(1)
+		command2 = buildCommand(2, "pop-char")
+		command3 = buildCommand(3, "pop-char")
+		command4 = buildCommand(4)
+		organizer = new Organizer()
+
+	describe "#addCommand", ->
+
+		it "will add unsynced commands", ->
+			organizer.addCommand command1
+			expect(organizer.unsyncedCommands).toEqual [ command1 ]
+
+		it "will add synced commands", ->
+			organizer.addCommand command1, false
+			expect(organizer.syncedCommands).toEqual [ command1 ]
+
+	describe "#addCommands", ->
+
+		it "will add multiple unsynced commands", ->
+			organizer.addCommands [ command1, command2 ]
+			expect(organizer.unsyncedCommands).toEqual [ command1, command2 ]
+
+		it "will add multiple synced commands", ->
+			organizer.addCommands [ command1, command2 ], false
+			expect(organizer.syncedCommands).toEqual [ command1, command2 ]
+
+	describe "#markAsSynced", ->
+
+		it "will add the requested commands to the syncedCommands list", ->
+			organizer.addCommands [ command1, command2, command3 ]
+			organizer.markAsSynced [ command1, command2 ]
+			expect(organizer.syncedCommands).toEqual [ command1, command2 ]
+
+		it "will remove the requested commands from the unsyncedCommands list", ->
+			organizer.addCommands [ command1, command2, command3 ]
+			organizer.markAsSynced [ command1, command2 ]
+			expect(organizer.unsyncedCommands).toEqual [ command3 ]
+
+	describe "#markAsInactive", ->
+
+		it "will add the requested commands to the inactiveCommands list", ->
+			organizer.addCommands [ command1, command2, command3 ]
+			organizer.markAsInactive [ command1, command2 ]
+			expect(organizer.inactiveCommands).toEqual [ command1, command2 ]
+
+		it "will remove requested commands from the syncedCommands list", ->
+			organizer.addCommands [ command1, command2, command3 ], false
+			organizer.markAsInactive [ command1, command2 ]
+			expect(organizer.syncedCommands).toEqual [ command3 ]
+
+	describe "#activeCommands", ->
+
+		it "will return a concatenated list of synced and unsynced commands", ->
+			organizer.addCommands [ command2, command4 ]
+			organizer.addCommands [ command1, command3 ], false
+			expect(organizer.activeCommands().length).toEqual 4
+			expect(command in organizer.activeCommands()).toBeTruthy() for command in organizer.unsyncedCommands
+			expect(command in organizer.activeCommands()).toBeTruthy() for command in organizer.syncedCommands
+
+		it "will sort the list of commands by timestamp", ->
+			organizer.addCommands [ command2, command4 ]
+			organizer.addCommands [ command1, command3 ], false
+			expect(organizer.activeCommands()).toEqual [ command1, command2, command3, command4 ]

data/spec/jasmine/tests/commands/processor_spec.coffee

@@ -0,0 +1,22 @@
+Client = require 'leonidas/client'
+Processor = require 'leonidas/commands/processor'
+
+describe "Processor", ->
+	processor = null
+	client = null
+
+	beforeEach ->
+		client = buildClient()
+		processor = new Processor([ new IncrementHandler(client.activeState), new PopCharHandler(client.activeState)])
+
+	describe "#processCommand", ->
+
+		it "will run a command", ->
+			processor.processCommand buildCommand(1)
+			expect(client.activeState).toEqual { integer: 2, string: "test" }
+
+	describe "#processCommands", ->
+
+		it "will run multiple commands", ->
+			processor.processCommands [ buildCommand(1), buildCommand(2, "pop-char") ]
+			expect(client.activeState).toEqual { integer: 2, string: "tes" }

data/spec/jasmine/tests/commands/stabilizer_spec.coffee

@@ -0,0 +1,30 @@
+Client = require 'leonidas/client'
+Organizer = require 'leonidas/commands/organizer'
+Processor = require 'leonidas/commands/processor'
+Stabilizer = require 'leonidas/commands/stabilizer'
+
+describe "Stabilizer", ->
+	stabilizer = null
+	client = null
+	organizer = null
+
+	beforeEach ->
+		client = buildClient()
+		organizer = new Organizer()
+		organizer.addCommands [ buildCommand(1), buildCommand(2, "pop-char"), buildCommand(3, "pop-char"), buildCommand(4) ], false
+		processor = new Processor([ new IncrementHandler(client.activeState), new PopCharHandler(client.activeState)])
+		stabilizer = new Stabilizer(client, organizer, processor)
+
+	describe "#stabilize", ->
+
+		it "will update the locked state to the state at the given timestamp", ->
+			stabilizer.stabilize 2
+			expect(client.lockedState).toEqual { integer: 2, string: "tes" }
+
+		it "will deactivate the stable commands in the command organizer", ->
+			stabilizer.stabilize 2
+			expect(organizer.activeCommands()).toEqual [ buildCommand(3, "pop-char"), buildCommand(4) ]
+
+		it "will process the remaining active commands to leave the active state entirely current", ->
+			stabilizer.stabilize 2
+			expect(client.activeState).toEqual { integer: 3, string: "te" }

data/spec/jasmine/tests/commands/synchronizer_spec.coffee

@@ -0,0 +1,72 @@
+Organizer = require 'leonidas/commands/organizer'
+Processor = require 'leonidas/commands/processor'
+Stabilizer = require 'leonidas/commands/stabilizer'
+Synchronizer = require 'leonidas/commands/synchronizer'
+
+describe "Synchronizer", ->
+	command1 = command4 = command5 = command7 = null
+	client = null
+	organizer = null
+	synchronizer = null
+
+	beforeEach ->
+		client = buildClient()
+		organizer = new Organizer()
+		command1 = buildCommand(1)
+		command4 = buildCommand(4, "pop-char")
+		command5 = buildCommand(5, "pop-char")
+		command7 = buildCommand(7)
+		processor = new Processor([ new IncrementHandler(client.activeState), new PopCharHandler(client.activeState)])
+		stabilizer = new Stabilizer(client, organizer, processor)
+		synchronizer = new Synchronizer("http://mydomain.com/sync", client, organizer, stabilizer)
+
+	describe "#push", ->
+
+		beforeEach ->
+			organizer.addCommands [ command1, command4 ]
+
+		describe "when successful", ->
+
+			it "will mark the commands pushed as synced", ->
+				spyOn($,"ajax").andCallFake( (params)-> params.success(mocks.syncPushResponse))
+				synchronizer.push()
+				expect(organizer.syncedCommands).toEqual [ command1, command4 ]
+				expect(organizer.unsyncedCommands).toEqual [ ]
+
+			it "will not mark unsynced commands added since push was called as synced", ->
+				spyOn($,"ajax").andCallFake( (params)-> 
+					organizer.addCommands [ command5, command7 ]
+					params.success(mocks.syncPushResponse)
+				)
+				synchronizer.push()
+				expect(organizer.syncedCommands).toEqual [ command1, command4 ]
+				expect(organizer.unsyncedCommands).toEqual [ command5, command7 ]
+
+	describe "#pull", ->
+
+		describe "when successful", ->
+
+			beforeEach ->
+				organizer.addCommands [ command1, command4 ], false
+				spyOn($,"ajax").andCallFake( (params)-> params.success(mocks.syncPullResponse))
+
+			it "will update the list of external clients and their latest timestamps", ->
+				synchronizer.pull()
+				expect(synchronizer.externalClients).toEqual [ { id: "2345", lastUpdate: 2 }, { id: "3456", lastUpdate: 8 } ]
+
+			it "will add the list of received commands as synced commands", ->
+				synchronizer.pull()
+				expect(organizer.syncedCommands.length).toEqual 3
+				expect(organizer.syncedCommands[0].toHash()).toEqual { name: 'pop-char',  data: { }, timestamp: 4 },
+				expect(organizer.syncedCommands[1].toHash()).toEqual { name: 'increment', data: { }, timestamp: 6 },
+				expect(organizer.syncedCommands[2].toHash()).toEqual { name: 'increment', data: { }, timestamp: 8 }
+
+			it "will lock to a new stable state", ->
+				synchronizer.pull()
+				expect(client.lockedState).toEqual { integer: 2, string: "tes" }
+
+			it "will deactivate stable commands", ->
+				synchronizer.pull()
+				expect(organizer.inactiveCommands.length).toEqual 2
+				expect(organizer.inactiveCommands[0].toHash()).toEqual { name: 'increment',  data: { }, timestamp: 1 },
+				expect(organizer.inactiveCommands[1].toHash()).toEqual { name: 'pop-char', data: { }, timestamp: 2 },

data/spec/rspec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'leonidas'
+%w(app commands persistence).each {|file| require_relative "support/classes/#{file}"}
+require_relative 'support/mocks'
+require_relative 'support/objects'

data/spec/rspec/support/classes/app.rb

@@ -0,0 +1,26 @@
+module TestClasses
+
+	class TestApp
+		include ::Leonidas::App::App
+		
+		def initialize(name="app 1")
+			@name = name
+			@persist_state = false
+			@locked_state = { value: 0 }
+			@active_state = { value: 1 }
+			@connections = [ ]
+			@processor = ::Leonidas::Commands::Processor.new([ IncrementHandler.new(self), MultiplyHandler.new(self) ])
+		end
+
+		def state=(val)
+			@locked_state = val.dup
+			@active_state = val.dup
+		end
+
+	end
+
+	class TestRepositoryContainer
+		include ::Leonidas::App::AppRepository
+	end
+
+end

data/spec/rspec/support/classes/commands.rb

@@ -0,0 +1,52 @@
+module TestClasses
+
+	class IncrementHandler 
+		include ::Leonidas::Commands::Handler
+
+		def initialize(app)
+			@app = app
+		end
+
+		def handles?(command)
+			command.name == "increment"
+		end
+
+		def run(command)
+			@app.current_state[:value] += command.data[:increment_by]
+		end
+
+		def persist(command)
+			TestClasses::PersistentState.value += command.data[:increment_by]
+		end
+	end
+
+	class MultiplyHandler 
+		include ::Leonidas::Commands::Handler
+
+		def initialize(app)
+			@app = app
+		end
+
+		def handles?(command)
+			command.name == "multiply"
+		end
+
+		def run(command)
+			@app.current_state[:value] *= command.data[:multiply_by]
+		end
+
+		def persist(command)
+			TestClasses::PersistentState.value *= command.data[:multiply_by]
+		end
+	end
+
+	class TestAggregator
+		include ::Leonidas::Commands::Aggregator
+
+		def initialize
+				@active_commands = [ ]
+				@inactive_commands = [ ]
+			end
+	end
+
+end