tunnelbroker 0.1.0

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# -*- coding: UTF-8 -*-
+require 'rspec'
+require 'coveralls'
+require 'simplecov'
+
+SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+SimpleCov.start do
+  add_filter 'spec/'
+end
+
+require 'tunnelbroker'

data/spec/unit/tunnelbroker/api_response_spec.rb

@@ -0,0 +1,414 @@
+# -*- coding: UTF-8 -*-
+require 'spec_helper'
+
+# Mock class for testing API responses
+#
+class MockResponse
+  attr_reader :lines
+
+  def initialize(text)
+    @lines = [text]
+  end
+end
+
+describe TunnelBroker::APIResponse do
+  describe '::BADAUTH' do
+    subject { TunnelBroker::APIResponse::BADAUTH }
+
+    it { should be_an_instance_of Regexp }
+
+    it 'should match the right string' do
+      s = 'badauth'
+      m = subject.match(s)
+      expect(m[1]).to eql 'badauth'
+    end
+  end
+
+  describe '::CHANGE' do
+    subject { TunnelBroker::APIResponse::CHANGE } # obama
+
+    it { should be_an_instance_of Regexp }
+
+    it 'should match the right string' do
+      s = 'good 127.0.0.1'
+      m = subject.match(s)
+      expect(m[1]).to eql 'good'
+      expect(m[2]).to eql '127.0.0.1'
+    end
+  end
+
+  describe '::NO_CHANGE' do
+    subject { TunnelBroker::APIResponse::NO_CHANGE }
+
+    it { should be_an_instance_of Regexp }
+
+    it 'should match the right string' do
+      s = 'nochg 127.0.0.1'
+      m = subject.match(s)
+      expect(m[1]).to eql 'nochg'
+      expect(m[2]).to eql '127.0.0.1'
+    end
+  end
+
+  describe '.matched_response' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:matched_response, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.send(:matched_response) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given a match' do
+      subject do
+        TunnelBroker::APIResponse.new(MockResponse.new('nochg 127.0.0.1'))
+      end
+      let(:m) { TunnelBroker::APIResponse::NO_CHANGE }
+      let(:thematch) { m.match('nochg 127.0.0.1') }
+
+      it 'should return a Hash for .response' do
+        subject.send(:matched_response, thematch)
+        expect(subject.response).to be_an_instance_of Hash
+      end
+
+      it 'should return the exepcted Hash for .response' do
+        subject.send(:matched_response, thematch)
+        expect(subject.response)
+          .to eql(msg: thematch[1], data: { ip: thematch[2] })
+      end
+    end
+  end
+
+  describe '.no_change' do
+    context 'when given more than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:no_change, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.send(:no_change) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a match' do
+      subject do
+        TunnelBroker::APIResponse.new(MockResponse.new('nochg 127.0.0.1'))
+      end
+      let(:m) { TunnelBroker::APIResponse::NO_CHANGE }
+      let(:thematch) { m.match('nochg 127.0.0.1') }
+
+      it 'should return true for .success?' do
+        subject.send(:no_change, thematch)
+        expect(subject.success?).to be_truthy
+      end
+
+      it 'should return false for .changed?' do
+        subject.send(:no_change, thematch)
+        expect(subject.changed?).to be_falsey
+      end
+
+      it 'should return a Hash for .response' do
+        subject.send(:no_change, thematch)
+        expect(subject.response).to be_an_instance_of Hash
+      end
+
+      it 'should return the exepcted Hash for .response' do
+        subject.send(:no_change, thematch)
+        expect(subject.response)
+          .to eql(msg: thematch[1], data: { ip: thematch[2] })
+      end
+    end
+  end
+
+  describe '.change' do
+    context 'when given more than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:change, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.send(:change) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a match' do
+      subject do
+        TunnelBroker::APIResponse.new(MockResponse.new('good 127.0.0.1'))
+      end
+      let(:m) { TunnelBroker::APIResponse::CHANGE }
+      let(:thematch) { m.match('good 127.0.0.1') }
+
+      it 'should return true for .success?' do
+        subject.send(:change, thematch)
+        expect(subject.success?).to be_truthy
+      end
+
+      it 'should return true for .changed?' do
+        subject.send(:change, thematch)
+        expect(subject.success?).to be_truthy
+      end
+
+      it 'should return a Hash for .response' do
+        subject.send(:change, thematch)
+        expect(subject.response).to be_an_instance_of Hash
+      end
+
+      it 'should return the expected Hash for .response' do
+        subject.send(:change, thematch)
+        expect(subject.response)
+          .to eql(msg: thematch[1], data: { ip: thematch[2] })
+      end
+    end
+  end
+
+  describe '.bad_auth' do
+    context 'when given more than two args' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:bad_auth, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.send(:bad_auth) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when passed a match' do
+      subject do
+        TunnelBroker::APIResponse.new(MockResponse.new('badauth'))
+      end
+      let(:m) { TunnelBroker::APIResponse::BADAUTH }
+      let(:thematch) { m.match('badauth') }
+
+      it 'should return false for .success?' do
+        subject.send(:bad_auth, thematch)
+        expect(subject.success?).to be_falsey
+      end
+
+      it 'should return false for .changed?' do
+        subject.send(:bad_auth, thematch)
+        expect(subject.changed?).to be_falsey
+      end
+
+      it 'should return a Hash for .response' do
+        subject.send(:bad_auth, thematch)
+        expect(subject.response).to be_an_instance_of Hash
+      end
+
+      it 'should return the expected Hash for .response' do
+        subject.send(:bad_auth, thematch)
+        expect(subject.response)
+          .to eql(msg: thematch[1], data: {})
+      end
+    end
+  end
+
+  describe '.parse_response' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:parse_response, nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.send(:parse_response) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given a badauth string' do
+      before do
+        m = TunnelBroker::APIResponse::BADAUTH
+        @md = m.match('badauth')
+        allow_any_instance_of(TunnelBroker::APIResponse)
+          .to receive(:bad_auth).with(@md).and_return('hello')
+      end
+
+      subject do
+        TunnelBroker::APIResponse.new(
+          MockResponse.new('badauth')
+        ).send(:parse_response, 'badauth')
+      end
+
+      it { should be_an_instance_of String }
+
+      it { should eql 'hello' }
+    end
+
+    context 'when given a change string' do
+      before do
+        m = TunnelBroker::APIResponse::CHANGE
+        @md = m.match('good 127.0.0.1')
+        allow_any_instance_of(TunnelBroker::APIResponse)
+          .to receive(:change).with(@md).and_return('hi')
+      end
+
+      subject do
+        TunnelBroker::APIResponse.new(
+          MockResponse.new('good 127.0.0.1')
+        ).send(:parse_response, 'good 127.0.0.1')
+      end
+
+      it { should be_an_instance_of String }
+
+      it { should eql 'hi' }
+    end
+
+    context 'when given a no_change string' do
+      before do
+        m = TunnelBroker::APIResponse::NO_CHANGE
+        @md = m.match('nochg 127.0.0.1')
+        allow_any_instance_of(TunnelBroker::APIResponse)
+          .to receive(:no_change).with(@md).and_return('wat')
+      end
+
+      subject do
+        TunnelBroker::APIResponse.new(
+          MockResponse.new('nochg 127.0.0.1')
+        ).send(:parse_response, 'nochg 127.0.0.1')
+      end
+
+      it { should be_an_instance_of String }
+
+      it { should eql 'wat' }
+    end
+
+    context 'when given a non-matching string' do
+      subject do
+        TunnelBroker::APIResponse.new(
+          MockResponse.new('madness')
+        )
+      end
+
+      it 'should not set a response value' do
+        expect(subject.send(:parse_response, 'madness')).to be_nil
+        expect(subject.response).to be_nil
+      end
+    end
+  end
+
+  describe '.changed?' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.changed?(nil) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when @changed is true' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('good 127.0.0.1'))
+      end
+      subject { @t.changed? }
+
+      it { should be_truthy }
+    end
+
+    context 'when @changed is false' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('nochg 127.0.0.1'))
+      end
+      subject { @t.changed? }
+
+      it { should be_falsey }
+    end
+
+    context 'when @changed is not defined' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('good 127.0.0.1'))
+        @t.remove_instance_variable(:@changed)
+      end
+      subject { @t.changed? }
+
+      it { should be_falsey }
+    end
+  end
+
+  describe '.success?' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect { subject.success?(nil) }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when @success is true' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('good 127.0.0.1'))
+      end
+      subject { @t.success? }
+
+      it { should be_truthy }
+    end
+
+    context 'when @success is false' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('badauth'))
+      end
+      subject { @t.success? }
+
+      it { should be_falsey }
+    end
+
+    context 'when @success is not defined' do
+      before do
+        @t = TunnelBroker::APIResponse.new(MockResponse.new('good 127.0.0.1'))
+        @t.remove_instance_variable(:@success)
+      end
+      subject { @t.success? }
+
+      it { should be_falsey }
+    end
+  end
+
+  describe '.new' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          TunnelBroker::APIResponse.new(nil, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          TunnelBroker::APIResponse.new
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given a response-like object' do
+      subject do
+        TunnelBroker::APIResponse.new(
+          MockResponse.new('good 127.0.0.1')
+        )
+      end
+
+      it { should be_an_instance_of TunnelBroker::APIResponse }
+
+      it 'should call parse_response' do
+        expect(subject.success?).to be_truthy
+        expect(subject.changed?).to be_truthy
+        expect(subject.response).to be_an_instance_of Hash
+      end
+    end
+  end
+end

data/spec/unit/tunnelbroker/client_spec.rb

@@ -0,0 +1,318 @@
+# -*- coding: UTF-8 -*-
+require 'uri'
+require 'spec_helper'
+
+# MockConfig class
+# for .build_messenger_config
+class MockConfig
+  @@url = nil
+  def self.url
+    @@url
+  end
+  def self.url=(url_in)
+    @@url = url_in
+  end
+
+  def self.username
+    'theckman'
+  end
+  def self.update_key
+    'abc123'
+  end
+  def self.tunnelid
+    '1234'
+  end
+  def self.ip4addr
+    '127.0.0.1'
+  end
+end
+
+# MockMessenger class
+# for submit_update testing
+class MockMessenger
+  attr_reader :x
+  def initialize(xa)
+    @x = xa
+  end
+
+  def call_api
+    x
+  end
+end
+
+describe TunnelBroker::Client do
+  describe '::ENDPOINT' do
+    subject { TunnelBroker::Client::ENDPOINT }
+
+    it { should be_an_instance_of String }
+
+    it 'should match the URI regexp' do
+      expect(URI.regexp.match(subject)).to_not be_nil
+    end
+
+    it 'should use HTTPS' do
+      u = URI(subject)
+      expect(u.scheme.downcase).to eql 'https'
+    end
+  end
+
+  describe '.config' do
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:config, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when @config does not exist' do
+      subject { TunnelBroker::Client.new.send(:config) }
+
+      it { should be_an_instance_of TunnelBroker::Configuration }
+    end
+
+    context 'when @config does exist' do
+      before do
+        @tbc = TunnelBroker::Client.new
+        @tbc.instance_variable_set(
+          :@config, TunnelBroker::Configuration.new
+        )
+      end
+      subject { @tbc.send(:config) }
+
+      it { should be_an_instance_of TunnelBroker::Configuration }
+    end
+  end
+
+  describe '.build_messenger_config' do
+    before do
+      @tbc = TunnelBroker::Client.new
+      allow(@tbc).to receive(:config).and_return(MockConfig)
+    end
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          subject.send(:build_messenger_config, nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'irrespective of what the config options are' do
+      it 'should try to build the config with each config item' do
+        TunnelBroker::Configuration::FIELDS.each do |c|
+          expect(@tbc).to receive(:config_hash_item).with(c).and_return({})
+        end
+        @tbc.send(:build_messenger_config)
+      end
+    end
+
+    context 'when none of the config options are set' do
+      before do
+        allow(MockConfig).to receive(:username).and_return(nil)
+        allow(MockConfig).to receive(:update_key).and_return(nil)
+        allow(MockConfig).to receive(:tunnelid).and_return(nil)
+        allow(MockConfig).to receive(:ip4addr).and_return(nil)
+      end
+      subject { @tbc.send(:build_messenger_config) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql(url: TunnelBroker::Client::ENDPOINT) }
+    end
+
+    context 'when all of the config options are set' do
+      before do
+        @cfg = {
+          url: TunnelBroker::Client::ENDPOINT,
+          username: MockConfig.username,
+          update_key: MockConfig.update_key,
+          tunnelid: MockConfig.tunnelid,
+          ip4addr: MockConfig.ip4addr
+        }
+      end
+
+      subject { @tbc.send(:build_messenger_config) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql @cfg }
+    end
+  end
+
+  describe '.config_hash_item' do
+    before do
+      @tbc = TunnelBroker::Client.new
+      allow(@tbc).to receive(:config).and_return(MockConfig)
+    end
+
+    context 'when given more than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          @tbc.send(:config_hash_item)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given less than one arg' do
+      it 'should raise ArgumentError' do
+        expect do
+          @tbc.send(:config_hash_item)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when given a key that is not valid' do
+      before do
+        @key = :fakeitem
+      end
+
+      it 'should not be a valid key' do
+        expect(TunnelBroker::Configuration::FIELDS.include?(@key))
+          .to be_falsey
+      end
+
+      it 'should raise NoMethodError' do
+        expect do
+          @tbc.send(:config_hash_item, @key)
+        end.to raise_error NoMethodError
+      end
+    end
+
+    context 'when given a valid key that is unset' do
+      before do
+        @key = :username
+        allow(MockConfig).to receive(:username).and_return(nil)
+      end
+
+      it 'should be a valid key' do
+        expect(TunnelBroker::Configuration::FIELDS.include?(@key))
+          .to be_truthy
+      end
+
+      subject { @tbc.send(:config_hash_item, @key) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql({}) }
+    end
+
+    context 'when given a valid key that is set' do
+      before do
+        @key = :username
+      end
+
+      it 'should be a valid key' do
+        expect(TunnelBroker::Configuration::FIELDS.include?(@key))
+          .to be_truthy
+      end
+
+      subject { @tbc.send(:config_hash_item, @key) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql(username: 'theckman') }
+    end
+
+    context 'when given :url and it being unset' do
+      before do
+        @key = :url
+      end
+
+      it 'should be a valid key' do
+        expect(TunnelBroker::Configuration::FIELDS.include?(@key))
+          .to be_truthy
+      end
+
+      subject { @tbc.send(:config_hash_item, @key) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql(url: TunnelBroker::Client::ENDPOINT) }
+    end
+
+    context 'when given :url and it being unset' do
+      before do
+        @key = :url
+        allow(MockConfig).to receive(:url).and_return('http://tb.io/')
+      end
+
+      it 'should be a valid key' do
+        expect(TunnelBroker::Configuration::FIELDS.include?(@key))
+          .to be_truthy
+      end
+
+      subject { @tbc.send(:config_hash_item, @key) }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql(url: 'http://tb.io/') }
+    end
+  end
+
+  describe '.submit_update' do
+    before do
+      @tbc = TunnelBroker::Client.new
+    end
+
+    context 'when given any args' do
+      it 'to raise ArgumentError' do
+        expect do
+          @tbc.submit_update(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when submitted with no args' do
+      before do
+        allow(@tbc).to receive(:config).and_return(MockConfig)
+        allow(@tbc).to receive(:build_messenger_config).and_return(
+          x: 'wat'
+        )
+        allow(TunnelBroker::Messenger).to receive(:new) do |arg1|
+          MockMessenger.new(arg1)
+        end
+      end
+
+      subject { @tbc.submit_update }
+
+      it { should be_an_instance_of Hash }
+
+      it { should eql(x: 'wat') }
+    end
+  end
+
+  describe '.configure' do
+    before do
+      @tbc = TunnelBroker::Client.new
+    end
+
+    context 'when given any args' do
+      it 'should raise ArgumentError' do
+        expect do
+          @tbc.configure(nil)
+        end.to raise_error ArgumentError
+      end
+    end
+
+    context 'when called with a block' do
+      before do
+        allow(@tbc).to receive(:config).and_return('configObj')
+      end
+
+      it 'should yield control' do
+        expect { |b| @tbc.configure(&b) }.to yield_control
+      end
+
+      it 'should yield the object returned from .config' do
+        expect { |b| @tbc.configure(&b) }.to yield_with_args('configObj')
+      end
+    end
+
+    context 'when not called with a block' do
+      subject { @tbc.configure }
+
+      it { should be_nil }
+    end
+  end
+end