cgminer_api_client 0.2.6 → 0.4.0

data/spec/cgminer_api_client/miner/commands_spec.rb

@@ -1,501 +0,0 @@
-require 'spec_helper'
-
-describe CgminerApiClient::Miner::Commands do
-  let(:host)     { '127.0.0.1' }
-  let(:port)     { 4028 }
-  let(:instance) { CgminerApiClient::Miner.new(host, port) }
-
-  describe CgminerApiClient::Miner::Commands::ReadOnly do
-    context '#asc' do
-      it 'should require one argument' do
-        expect {
-          instance.asc
-        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-      end
-
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:asc, 0).and_return('asc' => {})
-        instance.asc(0)
-      end
-    end
-
-    context '#asccount' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:asccount).and_return('asccount' => {})
-        instance.asccount
-      end
-    end
-
-    context '#check' do
-      it 'should require one argument' do
-        expect {
-          instance.check
-        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-      end
-
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:check, :foo).and_return('foo' => [{}])
-        instance.check(:foo)
-      end
-    end
-
-    context '#coin' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:coin).and_return('coin' => [{}])
-        instance.coin
-      end
-    end
-
-    context '#config' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:config).and_return('config' => [{}])
-        instance.config
-      end
-    end
-
-    context '#devdetails' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:devdetails).and_return('devdetails' => [{}])
-        instance.devdetails
-      end
-    end
-
-    context '#devs' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:devs).and_return('devs' => [{}])
-        instance.devs
-      end
-    end
-
-    context '#pga' do
-      it 'should require one argument' do
-        expect {
-          instance.pga
-        }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-      end
-
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:pga, 0).and_return('pga' => [{}])
-        instance.pga(0)
-      end
-    end
-
-    context '#pgacount' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:pgacount).and_return('pgacount' => [{}])
-        instance.pgacount
-      end
-    end
-
-    context '#pools' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:pools).and_return('pools' => [{}])
-        instance.pools
-      end
-    end
-
-    context '#privileged' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:privileged).and_return(nil)
-        instance.privileged
-      end
-
-      context 'an exception' do
-        before do
-          expect(instance).to receive(:query).with(:privileged).and_raise('something')
-        end
-
-        it 'should return false' do
-          expect(instance.privileged).to eq false
-        end
-      end
-
-      context 'success' do
-        before do
-          expect(instance).to receive(:query).with(:privileged).and_return(nil)
-        end
-
-        it 'should return true' do
-          expect(instance.privileged).to eq true
-        end
-      end
-    end
-
-    context '#notify' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:notify).and_return('notify' => [{}])
-        instance.notify
-      end
-    end
-
-    context '#stats' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:stats).and_return('stats' => [{}])
-        instance.stats
-      end
-    end
-
-    context '#summary' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:summary).and_return('summary' => [{}])
-        instance.summary
-      end
-    end
-
-    context '#usbstats' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:usbstats).and_return('usbstats' => [{}])
-        instance.usbstats
-      end
-    end
-
-    context '#version' do
-      it 'should query the miner' do
-        expect(instance).to receive(:query).with(:version).and_return('version' => [{}])
-        instance.version
-      end
-    end
-  end
-
-  describe CgminerApiClient::Miner::Commands::Privileged do
-    context 'access_denied?' do
-      context 'when not privileged' do
-        before do
-          allow(instance).to receive(:privileged).and_return(false)
-        end
-
-        it 'should raise an error' do
-          expect {
-            instance.send(:access_denied?)
-          }.to raise_error('access_denied')
-        end
-      end
-
-      context 'when privileged' do
-        before do
-          allow(instance).to receive(:privileged).and_return(true)
-        end
-
-        it 'should return false' do
-          expect(instance.send(:access_denied?)).to eq false
-        end
-      end
-    end
-
-    describe CgminerApiClient::Miner::Commands::Privileged::Asc do
-      before do
-        allow(instance).to receive(:access_denied?).and_return(false)
-      end
-
-      context 'ascdisable' do
-        it 'should require one argument' do
-          expect {
-            instance.ascdisable
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:ascdisable, :number)
-          instance.ascdisable(:number)
-        end
-      end
-
-      context 'ascenable' do
-        it 'should require one argument' do
-          expect {
-            instance.ascenable
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:ascenable, :number)
-          instance.ascenable(:number)
-        end
-      end
-
-      context 'ascidentify' do
-        it 'should require one argument' do
-          expect {
-            instance.ascidentify
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:ascidentify, :number)
-          instance.ascidentify(:number)
-        end
-      end
-
-      context 'ascset' do
-        it 'should require 2-3 arguments' do
-          expect {
-            instance.ascset
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2..3)')
-        end
-
-        it 'should query the miner with 2 arguments' do
-          expect(instance).to receive(:query).with(:ascset, :number, :foo)
-          instance.ascset(:number, :foo)
-        end
-
-        it 'should query the miner with 3 arguments' do
-          expect(instance).to receive(:query).with(:ascset, :number, :foo, :bar)
-          instance.ascset(:number, :foo, :bar)
-        end
-      end
-    end
-
-    describe CgminerApiClient::Miner::Commands::Privileged::Pga do
-      before do
-        allow(instance).to receive(:access_denied?).and_return(false)
-      end
-
-      context 'pgadisable' do
-        it 'should require one argument' do
-          expect {
-            instance.pgadisable
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:pgadisable, :number)
-          instance.pgadisable(:number)
-        end
-      end
-
-      context 'pgaenable' do
-        it 'should require one argument' do
-          expect {
-            instance.pgaenable
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:pgaenable, :number)
-          instance.pgaenable(:number)
-        end
-      end
-
-      context 'pgaidentify' do
-        it 'should require one argument' do
-          expect {
-            instance.pgaidentify
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:pgaidentify, :number)
-          instance.pgaidentify(:number)
-        end
-      end
-
-      context 'pgaset' do
-        it 'should require 2-3 arguments' do
-          expect {
-            instance.pgaset
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2..3)')
-        end
-
-        it 'should query the miner with 2 arguments' do
-          expect(instance).to receive(:query).with(:pgaset, :number, :foo)
-          instance.pgaset(:number, :foo)
-        end
-
-        it 'should query the miner with 3 arguments' do
-          expect(instance).to receive(:query).with(:pgaset, :number, :foo, :bar)
-          instance.pgaset(:number, :foo, :bar)
-        end
-      end
-    end
-
-    describe CgminerApiClient::Miner::Commands::Privileged::Pool do
-      before do
-        allow(instance).to receive(:access_denied?).and_return(false)
-      end
-
-      context 'addpool' do
-        it 'should require three arguments' do
-          expect {
-            instance.addpool
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 3)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:addpool, :url, :user, :pass)
-          instance.addpool(:url, :user, :pass)
-        end
-      end
-
-      context 'disablepool' do
-        it 'should require one argument' do
-          expect {
-            instance.disablepool
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:disablepool, :pool_number)
-          instance.disablepool(:pool_number)
-        end
-      end
-
-      context 'enablepool' do
-        it 'should require one argument' do
-          expect {
-            instance.enablepool
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:enablepool, :pool_number)
-          instance.enablepool(:pool_number)
-        end
-      end
-
-      context 'poolpriority' do
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:poolpriority, :pool_number_1, :pool_number_2, :pool_number_3)
-          instance.poolpriority(:pool_number_1, :pool_number_2, :pool_number_3)
-        end
-      end
-
-      context 'poolquota' do
-        it 'should require two arguments' do
-          expect {
-            instance.poolquota
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:poolquota, :pool_number, :quota)
-          instance.poolquota(:pool_number, :quota)
-        end
-      end
-
-      context 'removepool' do
-        it 'should require one argument' do
-          expect {
-            instance.removepool
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:removepool, :pool_number)
-          instance.removepool(:pool_number)
-        end
-      end
-
-      context 'switchpool' do
-        it 'should require one argument' do
-          expect {
-            instance.switchpool
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:switchpool, :pool_number)
-          instance.switchpool(:pool_number)
-        end
-      end
-    end
-
-    describe CgminerApiClient::Miner::Commands::Privileged::System do
-      before do
-        allow(instance).to receive(:access_denied?).and_return(false)
-      end
-
-      context 'debug' do
-        it 'should query the miner with defaults' do
-          expect(instance).to receive(:query).with(:debug, 'D')
-          instance.debug
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:debug, :setting)
-          instance.debug(:setting)
-        end
-      end
-
-      context 'failover_only' do
-        it 'should require one argument' do
-          expect {
-            instance.failover_only
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:'failover-only', :value)
-          instance.failover_only(:value)
-        end
-      end
-
-      context 'hotplug' do
-        it 'should require one argument' do
-          expect {
-            instance.hotplug
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 1)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:hotplug, :value)
-          instance.hotplug(:value)
-        end
-      end
-
-      context 'quit' do
-        it 'should query the miner' do
-          expect(instance).to receive(:query).with(:quit)
-          instance.quit
-        end
-      end
-
-      context 'restart' do
-        it 'should query the miner' do
-          expect(instance).to receive(:query).with(:restart)
-          instance.restart
-        end
-      end
-
-      context 'save' do
-        context 'without filename' do
-          it 'should query the miner' do
-            expect(instance).to receive(:query).with(:save)
-            instance.save
-          end
-        end
-
-        context 'with filename' do
-          it 'should query the miner with arguments' do
-            expect(instance).to receive(:query).with(:save, :filename)
-            instance.save(:filename)
-          end
-        end
-      end
-
-      context 'setconfig' do
-        it 'should require two arguments' do
-          expect {
-            instance.setconfig
-          }.to raise_error(ArgumentError, 'wrong number of arguments (given 0, expected 2)')
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:setconfig, :name, :value)
-          instance.setconfig(:name, :value)
-        end
-      end
-
-      context 'zero' do
-        it 'should query the miner with defaults' do
-          expect(instance).to receive(:query).with(:zero, 'All', false)
-          instance.zero
-        end
-
-        it 'should query the miner with arguments' do
-          expect(instance).to receive(:query).with(:zero, :which, :full_summary)
-          instance.zero(:which, :full_summary)
-        end
-      end
-    end
-  end
-end

data/spec/cgminer_api_client/miner_pool_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe CgminerApiClient::MinerPool do
-  let(:mock_miner)           { instance_double('CgminerApiClient::Miner') }
-  let(:host)                 { '127.0.0.1' }
-  let(:port)                 { 1234 }
-  let(:timeout)              { 10 }
-  let(:mock_miner_from_yaml) { double('miner_from_yaml', :[] => {'host' => host, 'port' => port, 'timeout' => timeout} ) }
-  let(:instance)             { CgminerApiClient::MinerPool.new }
-
-  before do
-    allow(CgminerApiClient::Miner).to receive(:new).and_return(mock_miner)
-  end
-
-  context 'attributes' do
-    context '@miners' do
-      before do
-        allow(File).to receive(:exist?).with('config/miners.yml').and_return(true)
-        allow_any_instance_of(CgminerApiClient::MinerPool).to receive(:load_miners!).and_return(true)
-      end
-
-      it 'should allow setting and getting' do
-        instance.miners = :foo
-        expect(instance.miners).to eq :foo
-      end
-    end
-  end
-
-  context '#initialize' do
-    it 'should load_miners!' do
-      expect_any_instance_of(CgminerApiClient::MinerPool).to receive(:load_miners!)
-      instance
-    end
-  end
-
-  context '#available_miners' do
-    it 'should not include unavailable miners'
-    it 'should include available miners'
-  end
-
-  context '#query' do
-    before do
-      allow(File).to receive(:exist?).with('config/miners.yml').and_return(true)
-      allow_any_instance_of(CgminerApiClient::MinerPool).to receive(:load_miners!).and_return(true)
-      allow(instance).to receive(:load_miners!).and_return(true)
-      instance.instance_variable_set(:@miners, [mock_miner])
-    end
-
-    it 'should run provided query on each miner' do
-      expect(mock_miner).to receive(:query).with(:foo)
-      instance.query(:foo)
-    end
-
-    it 'should pass parameters' do
-      expect(mock_miner).to receive(:query).with(:foo, :parameters)
-      instance.query(:foo, :parameters)
-    end
-
-    it 'should return an array' do
-      allow(mock_miner).to receive(:query).with(:foo)
-      expect(instance.query(:foo)).to be_kind_of(Array)
-    end
-  end
-
-  context '#method_missing' do
-    before do
-      allow(File).to receive(:exist?).with('config/miners.yml').and_return(true)
-      allow_any_instance_of(CgminerApiClient::MinerPool).to receive(:load_miners!).and_return(true)
-      allow(instance).to receive(:query).and_return(true)
-    end
-
-    it 'should query each miner with the method name' do
-      expect(instance).to receive(:query).with(:foo).and_return(true)
-      instance.method_missing(:foo)
-    end
-
-    it 'should pass arguments' do
-      expect(instance).to receive(:query).with(:foo, [:arguments])
-      instance.method_missing(:foo, [:arguments])
-    end
-  end
-
-  context '#reload_miners!' do
-    before do
-      allow(File).to receive(:exist?).with('config/miners.yml').and_return(true)
-      allow_any_instance_of(CgminerApiClient::MinerPool).to receive(:load_miners!).and_return(true)
-    end
-
-    it 'should call load_miners!' do
-      expect(instance).to receive(:load_miners!)
-      instance.reload_miners!
-    end
-  end
-
-  context 'private methods' do
-    context '#load_miners!' do
-      context 'without configuration file' do
-        before do
-          expect(File).to receive(:exist?).with('config/miners.yml').and_return(false)
-        end
-
-        it 'should raise an error' do
-          expect{
-            instance
-          }.to raise_error(RuntimeError)
-        end
-      end
-
-      context 'with configuration file' do
-        before do
-          allow(File).to receive(:exist?).with('config/miners.yml').and_return(true)
-        end
-
-        it 'should parse the configuration file' do
-          expect(YAML).to receive(:load_file).with('config/miners.yml').and_return([mock_miner_from_yaml]).at_least(:once)
-          instance.send(:load_miners!)
-        end
-
-        it 'should create new instances of CgminerApiClient::Miner' do
-          allow(YAML).to receive(:load_file).with('config/miners.yml').and_return([mock_miner_from_yaml])
-          expect(CgminerApiClient::Miner).to receive(:new).with(mock_miner_from_yaml[:host], mock_miner_from_yaml[:port], mock_miner_from_yaml[:timeout])
-          instance.send(:load_miners!)
-        end
-
-        it 'should assign the remote instances to @miners' do
-          allow(YAML).to receive(:load_file).with('config/miners.yml').and_return([mock_miner_from_yaml])
-          allow(CgminerApiClient::Miner).to receive(:new).with(mock_miner_from_yaml[:host], mock_miner_from_yaml[:port], mock_miner_from_yaml[:timeout]).and_return(mock_miner)
-          instance.send(:load_miners!)
-          expect(instance.miners).to eq [mock_miner]
-        end
-      end
-    end
-  end
-end