smite_ruby 1.4.3 → 1.4.5

data/spec/ability_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Ability do
+  it 'tests' do
+
+  end
+end

data/spec/achievements_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Achievements do
+  it 'tests' do
+
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Client do
+  let(:dev_id)   { 1234 }
+  let(:auth_key) { 'ABCD' }
+
+  describe '#initialize' do
+    it 'accepts only valid languages' do
+      [1,2,3,7,9,10,11,12,13].each do |lang|
+        client = described_class.new(dev_id, auth_key, lang)
+        expect(client.lang).to eq(lang)
+      end
+    end
+
+    it 'defaults the langauge to English' do
+      [14..20].each do |lang|
+        client = described_class.new(dev_id, auth_key, lang)
+        expect(client.lang).to eq(1)
+      end
+    end
+  end
+
+  describe '#valid_session?' do
+    let(:client) { described_class.new(dev_id, auth_key) }
+
+    it 'returns true if the session is created' do
+      expect(client.valid_session?).to eq(true)
+    end
+
+    it 'returns false if the session is not created' do
+      allow(client).to receive(:test_session).and_return('failure')
+      expect(client.valid_session?).to eq(false)
+    end
+  end
+
+  describe '#create_session' do
+    let(:client) { described_class.new(dev_id, auth_key) }
+
+    it 'sets the session_id if unset' do
+      allow(client).to receive(:valid_session?).and_return(false)
+      expect(client.session_id).to be_nil
+      client.create_session
+      expect(client.session_id).not_to be_nil
+    end
+
+    it 'returns the session_id if set' do
+      allow(client).to receive(:valid_session?).and_return(true)
+      expect(client).not_to receive(:api_call)
+      client.create_session
+    end
+  end
+end

data/spec/data_transform_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::DataTransform do
+  it 'tests' do
+
+  end
+end

data/spec/friend_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Friend do
+  it 'tests' do
+
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Game do
+  let(:dev_id)   { 1234 }
+  let(:auth_key) { 'ABCD' }
+
+  before { Smite::Game.authenticate!(dev_id, auth_key) }
+
+  describe '#authenticate!' do
+    it 'returns true if the client initialized a session' do
+      client = Smite::Client.new(dev_id, auth_key)
+      allow(client).to receive(:session_id).and_return('ABCDE')
+      allow(Smite::Client).to receive(:new).and_return(client)
+
+      expect(Smite::Game.authenticate!(dev_id, auth_key)).to eq(true)
+    end
+
+    it 'returns false if the client did not initialize a session' do
+      client = Smite::Client.new(dev_id, auth_key)
+      allow(client).to receive(:session_id).and_return(nil)
+      allow(Smite::Client).to receive(:new).and_return(client)
+
+      expect(Smite::Game.authenticate!(dev_id, auth_key)).to eq(false)
+    end
+  end
+
+  describe '#devices' do
+    it 'returns a list of Smite::Items' do
+      expect(Smite::Game.devices.count).to eq(3)
+      Smite::Game.devices.each do |device|
+        expect(device.class).to eq(Smite::Item)
+      end
+    end
+
+    it 'caches the devices' do
+      Smite::Game.devices
+      expect(Smite::Item).not_to receive(:new)
+      Smite::Game.devices
+    end
+  end
+
+  describe '#items' do
+    it 'only returns Items from the device list' do
+      Smite::Game.items.each do |item|
+        expect(item.type).to eq('Item')
+      end
+    end
+
+    it 'caches the items' do
+      Smite::Game.items
+      expect(Smite::Game.devices).not_to receive(:select)
+      Smite::Game.items
+    end
+  end
+
+  describe '#consumables' do
+    it 'only returns Consumables from the device list' do
+      Smite::Game.consumables.each do |consumable|
+        expect(consumable.type).to eq('Consumable')
+      end
+    end
+
+    it 'caches the consumables' do
+      Smite::Game.consumables
+      expect(Smite::Game.devices).not_to receive(:select)
+      Smite::Game.consumables
+    end
+  end
+
+  describe '#actives' do
+    it 'only returns Actives from the device list' do
+      Smite::Game.actives.each do |active|
+        expect(active.type).to eq('Active')
+      end
+    end
+
+    it 'caches the actives' do
+      Smite::Game.actives
+      expect(Smite::Game.devices).not_to receive(:select)
+      Smite::Game.actives
+    end
+  end
+
+  describe '#gods' do
+    it 'returns a list of Smite::God' do
+      expect(Smite::Game.gods.count).to eq(1)
+      Smite::Game.gods.each do |god|
+        expect(god.class).to eq(Smite::God)
+      end
+    end
+
+    it 'caches the gods' do
+      Smite::Game.gods
+      expect(Smite::God).not_to receive(:new)
+      Smite::Game.gods
+    end
+  end
+
+  describe '#motd_list' do
+    it 'returns a list of Smite::MOTDs' do
+      expect(Smite::Game.motd_list.count).to eq(3)
+      Smite::Game.motd_list.each do |motd|
+        expect(motd.class).to eq(Smite::MOTD)
+      end
+    end
+
+    it 'is in sorted order by date' do
+      motds = Smite::Game.motd_list
+      (0..motds.count - 2).each do |k|
+        expect(motds[k].date).to be > motds[k+1].date
+      end
+    end
+
+    it 'caches the motd_list' do
+      Smite::Game.motd_list
+      expect(Smite::MOTD).not_to receive(:new)
+      Smite::Game.motd_list
+    end
+  end
+
+  describe '#motd_now' do
+    it 'returns the most recent MOTD' do
+      expect(Smite::Game.motd_now).to eq(Smite::Game.motd_list[0])
+    end
+  end
+
+  describe '#god' do
+    it 'returns a god that matches by name' do
+      %w[agni AgNi AGNI].each do |name|
+        god = Smite::Game.god(name)
+        expect(god.name).to eq('Agni')
+      end
+    end
+
+    it 'returns a god that matches by id' do
+      [1737, '1737'].each do |id|
+        god = Smite::Game.god(id)
+        expect(god.name).to eq('Agni')
+      end
+    end
+
+    it 'returns nil for a god that doesnt exist' do
+      ['jesus', [], {'Alabama' => :AL }].each do |thing|
+        god = Smite::Game.god(thing)
+        expect(god).to eq(nil)
+      end
+    end
+  end
+
+  describe '#item' do
+    it 'returns an item that matches by name' do
+      %w[SOverEIGnty sovereignty SOVEREIGNTY].each do |name|
+        item = Smite::Game.item(name)
+        expect(item.name).to eq('Sovereignty')
+      end
+    end
+
+    it 'returns an item that matches by id' do
+      [7528, '7528'].each do |id|
+        item = Smite::Game.item(id)
+        expect(item.name).to eq('Sovereignty')
+      end
+    end
+
+    it 'returns nil for an item that doesnt exist' do
+      ['jesus', [], {'Alabama' => :AL }].each do |thing|
+        item = Smite::Game.item(thing)
+        expect(item).to eq(nil)
+      end
+    end
+  end
+
+  describe '#player' do
+    it 'instantiates a new Smite::Player' do
+      expect(Smite::Player).to receive(:new)
+      Smite::Game.player('adapting')
+    end
+  end
+
+  describe '#queues' do
+    it 'returns a list of queues' do
+      expect(Smite::Game.queues.count).to eq(9)
+      Smite::Game.queues.each do |queue|
+        expect(queue.class).to eq(Smite::Queue)
+      end
+    end
+
+    it 'caches the queue list' do
+      Smite::Game.queues
+      expect(Smite::Queue).not_to receive(:new)
+      Smite::Game.queues
+    end
+  end
+
+  describe '#match' do
+    it 'instantiates a new Smite::Match' do
+      # pending
+    end
+  end
+end

data/spec/god_rank_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::GodRank do
+  it 'tests' do
+
+  end
+end

data/spec/god_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+RSpec.describe Smite::God do
+  let(:osiris)    { Smite::Game.god('Osiris') }
+  let(:sobek)     { Smite::Game.god('Sobek') }
+  let(:agni)      { Smite::Game.god('Agni') }
+  let(:smite_obj) { agni }
+
+  before { Smite::Game.authenticate!(1234, 'ABCD') }
+
+  describe '#on_free_rotation?' do
+    it 'returns true if not empty' do
+      expect(agni.on_free_rotation?).to eq(true)
+    end
+    it 'returns false if empty' do
+      expect(sobek.on_free_rotation?).to eq(false)
+    end
+  end
+
+  describe '#ranged?' do
+    it 'returns true if type contains Ranged' do
+      expect(agni.ranged?).to eq(true)
+    end
+    it 'returns false if type does not contain Ranged' do
+      expect(sobek.ranged?).to eq(false)
+    end
+  end
+
+  describe '#melee?' do
+    it 'returns true if type contains Melee' do
+      expect(sobek.melee?).to eq(true)
+    end
+    it 'returns false if type does not contain Melee' do
+      expect(agni.melee?).to eq(false)
+    end
+  end
+
+  describe '#magic?' do
+    it 'returns true if type contains Magic' do
+      expect(agni.magic?).to eq(true)
+    end
+    it 'returns false if type does not contain Magic' do
+      expect(osiris.magic?).to eq(false)
+    end
+  end
+
+  describe '#physical?' do
+    it 'returns true if type contains Physical' do
+      expect(osiris.physical?).to eq(true)
+    end
+    it 'returns false if type does not contain Physical' do
+      expect(agni.physical?).to eq(false)
+    end
+  end
+
+  it_behaves_like 'a Smite::Object'
+end

data/spec/god_stats_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::GodStats do
+  it 'tests' do
+
+  end
+end

data/spec/item_effect_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+RSpec.describe Smite::ItemEffect do
+  it 'tests' do
+
+  end
+end

data/spec/item_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+RSpec.describe Smite::Item do
+  let(:vampiric_shroud) { Smite::Game.item("Vampiric Shroud") }
+  let(:shifters_shield) { Smite::Game.item("Shifter's Shield") }
+  let(:soul_reaver)     { Smite::Game.item('Soul Reaver') }
+  let(:sovereignty)     { Smite::Game.item('Sovereignty') }
+  let(:aegis)           { Smite::Game.item('Improved Aegis') }
+  let(:potion)          { Smite::Game.item('Potion of Magical Might') }
+  let(:smite_obj)       { sovereignty }
+
+  before { Smite::Game.authenticate!(1234, 'ABCD') }
+
+  describe '#active?' do
+    it 'returns true if the device is an active' do
+      expect(aegis.active?).to eq(true)
+    end
+    it 'returns false if the device is not an active' do
+      expect(sovereignty.active?).to eq(false)
+      expect(potion.active?).to eq(false)
+    end
+  end
+
+  describe '#consumable?' do
+    it 'returns true if the device is a consumable' do
+      expect(potion.consumable?).to eq(true)
+    end
+    it 'returns false if the device is not a consumable' do
+      expect(sovereignty.consumable?).to eq(false)
+      expect(aegis.consumable?).to eq(false)
+    end
+  end
+
+  describe '#item?' do
+    it 'returns true if the device is an item' do
+      expect(sovereignty.item?).to eq(true)
+    end
+    it 'returns false if the device is not an item' do
+      expect(potion.item?).to eq(false)
+      expect(aegis.item?).to eq(false)
+    end
+  end
+
+  describe '#physical?' do
+    it 'returns true if the device is a physical item' do
+      expect(sovereignty.physical?).to eq(true)
+      expect(shifters_shield.physical?).to eq(true)
+    end
+    it 'returns true if the device is an active or potion' do
+      expect(potion.physical?).to eq(true)
+      expect(aegis.physical?).to eq(true)
+    end
+    it 'returns false if the device is physical' do
+      expect(soul_reaver.physical?).to eq(false)
+    end
+  end
+
+  describe '#magic?' do
+    it 'returns true if the device is a magic item' do
+      expect(soul_reaver.magic?).to eq(true)
+      expect(sovereignty.magic?).to eq(true)
+    end
+    it 'returns true if the device is an active or potion' do
+      expect(potion.physical?).to eq(true)
+      expect(aegis.physical?).to eq(true)
+    end
+    it 'returns false if the device is magic' do
+      expect(shifters_shield.magic?).to eq(false)
+    end
+  end
+
+  describe '#starter?' do
+    it 'returns true if the device is a starter item' do
+      expect(vampiric_shroud.starter?).to eq(true)
+    end
+    it 'returns false otherwise' do
+      expect(potion.starter?).to eq(false)
+      expect(aegis.starter?).to eq(false)
+      expect(soul_reaver.starter?).to eq(false)
+      expect(sovereignty.starter?).to eq(false)
+    end
+  end
+
+  it_behaves_like 'a Smite::Object'
+end