cgminer_api_client 0.2.6

data/spec/cgminer_api_client/miner_pool_spec.rb

@@ -0,0 +1,134 @@
+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

data/spec/cgminer_api_client/miner_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+describe CgminerApiClient::Miner do
+  let(:host)     { '127.0.0.1' }
+  let(:port)     { 4028 }
+  let(:timeout)  { 1 }
+  let(:instance) { CgminerApiClient::Miner.new(host, port, timeout) }
+
+  context 'attributes' do
+    context '@host' do
+      it 'should allow setting and getting' do
+        instance.host = :foo
+        expect(instance.host).to eq :foo
+      end
+    end
+
+    context '@port' do
+      it 'should allow setting and getting' do
+        instance.port = :foo
+        expect(instance.port).to eq :foo
+      end
+    end
+
+    context '@timeout' do
+      it 'should allow setting and getting' do
+        instance.timeout = :foo
+        expect(instance.timeout).to eq :foo
+      end
+    end
+  end
+
+  context '#initialize' do
+    it 'should not raise an argument error with 0 arguments' do
+      expect {
+        CgminerApiClient::Miner.new
+      }.to_not raise_error()
+    end
+
+    it 'should not raise an argument error with 1 arguments' do
+      expect {
+        CgminerApiClient::Miner.new(host)
+      }.to_not raise_error()
+    end
+
+    it 'should not raise an argument error with 2 arguments' do
+      expect {
+        CgminerApiClient::Miner.new(host, port)
+      }.to_not raise_error()
+    end
+
+    it 'should not raise an argument error with 3 arguments' do
+      expect {
+        CgminerApiClient::Miner.new(host, port, timeout)
+      }.to_not raise_error()
+    end
+
+    it 'should use defaults' do
+      miner = CgminerApiClient::Miner.new
+      expect(miner.host).to eq CgminerApiClient.default_host
+      expect(miner.port).to eq CgminerApiClient.default_port
+      expect(miner.timeout).to eq CgminerApiClient.default_timeout
+    end
+
+    it 'should set @host' do
+      expect(instance.host).to eq host
+    end
+
+    it 'should set @port' do
+      expect(instance.port).to eq port
+    end
+
+    it 'should set @timeout' do
+      expect(instance.timeout).to eq timeout
+    end
+  end
+
+  context '#available?' do
+    let(:mock_socket) { instance_double('Socket') }
+
+    context 'open_socket raises an error' do
+      before do
+        expect(instance).to receive(:open_socket).and_raise(SocketError)
+      end
+
+      it 'should return false' do
+        expect(instance.available?).to eq false
+      end
+    end
+
+    context 'open_socket does not raise an error' do
+      before do
+        expect(instance).to receive(:open_socket).and_return(mock_socket)
+      end
+
+      context 'socket #close raises an error' do
+        before do
+          expect(mock_socket).to receive(:close).and_raise(SocketError)
+        end
+
+        it 'should return false' do
+          expect(instance.available?).to eq false
+        end
+      end
+
+      context 'socket #close does not raise an error' do
+        before do
+          expect(mock_socket).to receive(:close).and_return(:foo)
+        end
+
+        it 'should return true' do
+          expect(instance.available?).to eq true
+        end
+      end
+    end
+
+    it 'should set an instance variable' do
+      expect(instance).to receive(:open_socket).and_return(mock_socket)
+      expect(mock_socket).to receive(:close).and_return(true)
+      instance.available?
+      expect(instance.instance_variable_get(:@available)).to eq true
+    end
+  end
+
+  context '#query' do
+    context 'unavailable' do
+      before do
+        expect(instance).to receive(:available?).and_return(false)
+      end
+
+      it 'should not perform a command request' do
+        expect(instance).to receive(:perform_request).never
+        instance.query(:foo)
+      end
+
+      it 'should return nil' do
+        expect(instance.query(:foo)).to eq nil
+      end
+    end
+
+    context 'available' do
+      before do
+        expect(instance).to receive(:available?).and_return(true)
+      end
+
+      context 'no parameters' do
+        it 'should perform a command request' do
+          expect(instance).to receive(:perform_request).with({:command => :foo}).and_return({'foo' => []})
+          instance.query(:foo)
+        end
+      end
+
+      context 'parameters' do
+        it 'should perform a command request with parameters' do
+          expect(instance).to receive(:perform_request).with({:command => :foo, :parameter => 'bar,123,\\456'}).and_return({'foo' => []})
+          instance.query(:foo, :bar, :'123', :'\456')
+        end
+      end
+
+      it 'should return sanitized data' do
+        mock_data = double('data')
+        expect(instance).to receive(:perform_request).and_return(mock_data)
+        expect(instance).to receive(:sanitized).with(mock_data).and_return({:foo => []})
+        expect(instance.query(:foo)).to eq []
+      end
+
+      it 'should return sanitized data for multiple commands' do
+        mock_data = double('data')
+        expect(instance).to receive(:perform_request).and_return(mock_data)
+        expect(instance).to receive(:sanitized).with(mock_data).and_return({:foo => [], :bar => []})
+        expect(instance.query('foo+bar')).to eq ({:foo => [], :bar => []})
+      end
+    end
+  end
+
+  context '#method_missing' do
+    before do
+      allow(instance).to receive(:query).and_return(true)
+    end
+
+    it 'should query the 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 'private methods' do
+    context '#open_socket' do
+      pending
+    end
+
+    context '#perform_request' do
+      context 'Socket cannot be opened' do
+        before do
+          expect(instance).to receive(:open_socket).and_raise(SocketError)
+        end
+
+        it 'should raise an exception' do
+          expect {
+            instance.send(:perform_request, {})
+          }.to raise_error(RuntimeError, 'Connection to 127.0.0.1:4028 failed')
+        end
+      end
+
+      context 'Socket can be opened' do
+        let(:mock_socket) { instance_double('Socket', {
+          :write => true,
+          :read  => "{'json':true}",
+          :close => true
+        }) }
+
+        before do
+          expect(instance).to receive(:open_socket).and_return(mock_socket)
+        end
+
+        context 'single command' do
+          it 'should parse the response as JSON and check the status' do
+            expect(JSON).to receive(:parse).with(mock_socket.read)
+            expect(instance).to receive(:check_status).and_return(true)
+            instance.send(:perform_request, {})
+          end
+        end
+
+        context 'multiple commands' do
+          it 'should parse the response as JSON and check the status of each response element' do
+            expect(JSON).to receive(:parse).with(mock_socket.read).and_return({:foo => [{'STATUS' => 'ALL_GOOD'}], :bar => [{'STATUS' => 'NOT_SO_GOOD'}]})
+            expect(instance).to receive(:check_status).with({"STATUS" => 'ALL_GOOD'})
+            expect(instance).to receive(:check_status).with({"STATUS" => 'NOT_SO_GOOD'})
+            instance.send(:perform_request, {command: 'foo+bar'})
+          end
+        end
+      end
+    end
+
+    context '#check_status' do
+      let(:mock_response) { {} }
+
+      context 'with successful status' do
+        before do
+          mock_response['STATUS'] = [{'STATUS' => 'S'}]
+        end
+
+        it 'should not log a message or raise an error' do
+          expect(instance).to receive(:puts).never
+          expect(instance).to receive(:raise).never
+          instance.send(:check_status, mock_response)
+        end
+      end
+
+      context 'with info status' do
+        before do
+          mock_response['STATUS'] = [{'STATUS' => 'I'}]
+        end
+
+        it 'should log a message' do
+          expect(instance).to receive(:puts)
+          instance.send(:check_status, mock_response)
+        end
+      end
+
+      context 'with warning status' do
+        before do
+          mock_response['STATUS'] = [{'STATUS' => 'W'}]
+        end
+
+        it 'should log a message' do
+          expect(instance).to receive(:puts)
+          instance.send(:check_status, mock_response)
+        end
+      end
+
+      context 'with error' do
+        before do
+          mock_response['STATUS'] = [{'STATUS' => 'E'}]
+        end
+
+        it 'should raise an exception' do
+          expect(instance).to receive(:raise)
+          instance.send(:check_status, mock_response)
+        end
+      end
+    end
+
+    context '#sanitized' do
+      let(:mock_data) { {'Ugly Key' => :foo} }
+
+      it 'should produce sensible output' do
+        expect(instance.send(:sanitized, mock_data)).to eq ({:ugly_key => :foo})
+      end
+    end
+  end
+end

data/spec/cgminer_api_client_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe CgminerApiClient do
+  subject { CgminerApiClient }
+
+  before do
+    subject.default_timeout = 5
+    subject.default_port = 4028
+  end
+
+  it 'should have a version constant with major.minor.patch' do
+    expect(subject::VERSION).to_not be_empty
+    expect(subject::VERSION.split(/\./).length).to eq(3)
+  end
+
+  context 'module attributes' do
+    context 'default_timeout' do
+      it 'should allow setting and getting' do
+        subject.default_timeout = :foo
+        expect(subject.default_timeout).to eq :foo
+      end
+    end
+
+    context 'default_port' do
+      it 'should allow setting and getting' do
+        subject.default_port = :foo
+        expect(subject.default_port).to eq :foo
+      end
+    end
+  end
+
+  context '.config' do
+    it 'should yield a block if given' do
+      expect {
+        subject.config do |config|
+          config.default_timeout = :foo
+        end
+      }.to change { subject.default_timeout }.from(subject.default_timeout).to(:foo)
+    end
+  end
+end