forward 0.0.1 → 0.0.11

data/lib/forward/core_extensions.rb

@@ -0,0 +1,12 @@
+class Hash
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end

data/lib/forward/error.rb

@@ -0,0 +1,10 @@
+module Forward
+	# An error occurred with the API
+	class ApiError < StandardError; end
+	# An error occurred with the Client
+	class ClientError < StandardError; end
+	# An error occurred with the Config
+	class ConfigError < StandardError; end
+	# An error occurred with the Tunnel
+	class TunnelError < StandardError; end
+end

data/lib/forward/tunnel.rb

@@ -0,0 +1,58 @@
+module Forward
+  class Tunnel
+    CHECK_INTERVAL = 7
+
+    # The Tunnel resource ID.
+    attr_reader :id
+    # The domain for the Tunnel.
+    attr_reader :subdomain
+    # The remote port.
+    attr_reader :port
+    # The tunneler host.
+    attr_reader :tunneler
+    # The amount of time in seconds the Tunnel has be inactive for
+    attr_accessor :inactive_for
+
+    # Initializes a Tunnel instance for the Client and requests a tunnel from
+    # API.
+    #
+    # client - The Client instance.
+    def initialize(options = {})
+      @response     = Forward::Api::Tunnel.create(options)
+      @id           = @response[:_id]
+      @subdomain    = @response[:subdomain]
+      @port         = @response[:port]
+      @tunneler     = @response[:tunneler_public]
+      @timeout      = @response[:timeout]
+      @inactive_for = 0
+    end
+
+    def poll_status
+      Thread.new {
+        loop do
+          if @timeout && !@timeout.zero? && @inactive_for > @timeout
+            Forward.log(:debug, "Session closing due to inactivity `#{@inactive_for}' seconds")
+            Client.cleanup_and_exit!("Tunnel has been inactive for #{@inactive_for} seconds, exiting...")
+          elsif Forward::Api::Tunnel.show(@id).nil?
+            Client.current.tunnel = nil
+            Forward.log(:debug, "Tunnel destroyed, closing session")
+            Client.cleanup_and_exit!
+          else
+            sleep CHECK_INTERVAL
+          end
+
+          @inactive_for += CHECK_INTERVAL
+        end
+      }
+    end
+
+    def cleanup
+      Forward::Api::Tunnel.destroy(@id) if @id
+    end
+
+    def active?
+      @active
+    end
+
+  end
+end

data/lib/forward/version.rb

@@ -1,3 +1,3 @@
 module Forward
-  VERSION = '0.0.1'
+  VERSION = '0.0.11'
 end

data/test/api/public_key_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+describe Forward::Api::PublicKey do
+
+  before :each do
+    FakeWeb.allow_net_connect = false
+  end
+
+  it 'retrieves the public_key and returns it' do
+    fake_body = { :private_key => 'ssh-key 1234567890' }
+
+    stub_api_request(:post, '/api/public_keys', :body => fake_body.to_json)
+
+    response = Api::PublicKey.create
+    response.must_equal fake_body[:private_key]
+  end
+
+  it 'exits with message if response has errors' do
+    fake_body = { :errors => { :base => 'Unable to retrieve a private key' } }
+
+    stub_api_request(:post, '/api/public_keys', :body => fake_body.to_json)
+
+    lambda { 
+      dev_null { Api::PublicKey.create }
+    }.must_raise SystemExit
+  end
+
+end

data/test/api/resource_test.rb

@@ -0,0 +1,82 @@
+require 'test_helper'
+
+describe Forward::Api::Resource do
+  Api = Forward::Api
+
+  before :each do
+    Api.token = 'abc123'
+  end
+
+  it 'builds http requests based on given method' do
+    resource     = Api::Resource.new
+    resource.uri = '/path'
+
+    [ :get, :post, :put, :delete ].each do |method|
+      resource.build_request(method)
+      klass   = eval("Net::HTTP::#{method.capitalize}")
+      request = resource.instance_variable_get('@request')
+
+      request.kind_of?(klass).must_equal true
+    end
+  end
+
+  it 'builds http requests with json bodies' do
+    resource     = Api::Resource.new
+    resource.uri = '/path'
+
+    [ :post, :put, :delete ].each do |method|
+      params = { :foo => 'bar '}
+      resource.build_request(method, params)
+      klass   = eval("Net::HTTP::#{method.capitalize}")
+      request = resource.instance_variable_get('@request')
+
+      request.kind_of?(klass).must_equal true
+      request.body.must_equal params.to_json
+    end
+  end
+
+  it 'adds auth and json headers to the request' do
+    resource     = Api::Resource.new
+    resource.uri = '/path'
+    resource.build_request(:post)
+    resource.add_headers!
+    request = resource.instance_variable_get('@request')
+
+    request['Authorization'].must_equal "Token token=#{Api.token}"
+    request['Content-Type'].must_equal 'application/json'
+    request['Accept'].must_equal 'application/json'
+  end
+
+
+  it 'raises an error if the response code is not 200' do
+    resource = Api::Resource.new
+    response = mock
+    response.stubs(:code).returns(403)
+    response.stubs(:body)
+
+    lambda { resource.parse_response(response) }.must_raise Api::BadResponse
+  end
+
+  it 'raises an error if the response is not json' do
+    resource = Api::Resource.new
+    response = mock
+    response.stubs(:code).returns(200)
+    response.stubs(:body)
+    response.stubs(:[]).with('content-type').returns('text/html')
+
+    lambda { resource.parse_response(response) }.must_raise Api::BadResponse
+  end
+
+  it 'parses a json response' do
+    resource = Api::Resource.new
+    response = mock
+    response.stubs(:code).returns(200)
+    response.stubs(:[]).with('content-type').returns('application/json')
+    response.stubs(:body).returns('{ "foo": "bar" }')
+
+    json = resource.parse_response(response)
+    json.kind_of?(Hash).must_equal true
+    json[:foo].must_equal 'bar'
+  end
+
+end

data/test/api/tunnel_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+
+describe Forward::Api::Tunnel do
+
+  before :each do
+    FakeWeb.allow_net_connect = false
+    Forward::Api.token      = 'abc123'
+  end
+
+  it 'creates a tunnel and returns the attributes' do
+    Forward.client = mock
+    fake_body      = { :_id => '1', :subdomain => 'foo', :port => 56789 }
+
+    Forward.client.expects(:options).returns(:port => 3000)
+    stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
+
+    response = Forward::Api::Tunnel.create
+
+    fake_body.each do |key, value|
+      response[key].must_equal fake_body[key]
+    end
+  end
+
+  it 'exits with message if create response has errors' do
+    Forward.client = mock
+    fake_body      = { :errors => { :base => [ 'unable to create tunnel' ] } }
+
+    Forward.client.expects(:options).returns(:port => 3000)
+    stub_api_request(:post, '/api/tunnels', :body => fake_body.to_json)
+
+    lambda { 
+      dev_null { Forward::Api::Tunnel.create }
+    }.must_raise SystemExit
+  end
+
+  it 'gives a choice and closes a tunnel if limit is reached' do
+    Forward.client = mock
+    post_options   = [
+      { :body => { :errors => { :base => [ 'you have reached your limit' ] } }.to_json },
+      { :body => { :_id => '1', :subdomain => 'foo', :port => 56789 }.to_json }
+    ]
+    index_body     = [ { :_id => 'abc123' }, { :_id => 'def456' } ]
+
+    Forward.client.expects(:options).returns(:port => 3000).twice
+    stub_api_request(:post, '/api/tunnels', post_options)
+    stub_api_request(:get, '/api/tunnels', :body => index_body.to_json)
+    STDIN.expects(:gets).returns('1')
+    Forward::Api::Tunnel.expects(:destroy).with(index_body.first[:_id])
+
+    dev_null { Forward::Api::Tunnel.create }
+  end
+
+  it 'destroys a tunnel and returns the attributes' do
+    Forward.client = mock
+    fake_body      = { :_id => '1', :subdomain => 'foo', :port => 56789 }
+
+    stub_api_request(:delete, '/api/tunnels/1', :body => fake_body.to_json)
+
+    response = Forward::Api::Tunnel.destroy(1)
+
+    fake_body.each do |key, value|
+      response[key].must_equal fake_body[key]
+    end
+  end
+
+  it 'gracefully handles the error if destroy has errors' do
+    Forward.client = mock
+    fake_body      = { :errors => { :base => 'unable to create tunnel' } }
+
+    stub_api_request(:delete, '/api/tunnels/1', :body => fake_body.to_json)
+
+    Forward::Api::Tunnel.destroy(1).must_be_nil
+  end
+
+end

data/test/api/user_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+describe Forward::Api::User do
+
+  before :each do
+    FakeWeb.allow_net_connect = false
+  end
+
+  it 'retrieves the users api token and returns it' do
+    fake_body      = { :api_token => '123abc' }
+
+    stub_api_request(:post, '/api/users/api_token', :body => fake_body.to_json)
+
+    response = Api::User.api_token('guy@example.com', 'secret')
+    response[:api_token].must_equal '123abc'
+  end
+
+  it 'exits with message if response has errors' do
+    fake_body      = { :errors => { :base => 'Unable to authenticate user' } }
+
+    stub_api_request(:post, '/api/users/api_token', :body => fake_body.to_json)
+
+    lambda { 
+      dev_null { Api::User.api_token('guy@example.com', 'secret') }
+    }.must_raise SystemExit
+  end
+
+end

data/test/cli_test.rb

@@ -0,0 +1,84 @@
+require 'test_helper'
+
+describe Forward::CLI do
+
+  it 'parses a forwarded port' do
+    forwarded = Forward::CLI.parse_forwarded('600')
+    forwarded.has_key?(:port).must_equal true
+    forwarded[:port].must_equal 600
+  end
+
+  it 'parses a forwarded host' do
+    forwarded = Forward::CLI.parse_forwarded('mysite.dev')
+    forwarded.has_key?(:host).must_equal true
+    forwarded[:host].must_equal 'mysite.dev'
+  end
+
+  it 'parses a forwarded host and port' do
+    forwarded = Forward::CLI.parse_forwarded('mysite.dev:88')
+    forwarded.has_key?(:host).must_equal true
+    forwarded.has_key?(:port).must_equal true
+    forwarded[:host].must_equal 'mysite.dev'
+    forwarded[:port].must_equal 88
+  end
+
+  it 'parses valid basic auth and returns username and password' do
+    username = 'foo'
+    password = 'bar'
+
+    credentials = Forward::CLI.parse_basic_auth("#{username}:#{password}")
+    credentials.first.must_equal username
+    credentials.last.must_equal password
+  end
+
+  it 'validates basic auth and exits if invalid' do
+    [ 'afadsfsdf', 'adsf:', ':bar' ].each do |credentials|
+      lambda {
+        dev_null { Forward::CLI.validate_basic_auth(credentials) }
+      }.must_raise SystemExit
+    end
+  end
+
+  it 'doesnt exit on valid ports' do
+    Forward::CLI.validate_port(69).must_be_nil
+    Forward::CLI.validate_port(3000).must_be_nil
+    Forward::CLI.validate_port(65535).must_be_nil
+  end
+
+  it 'validates port and exits if invalid' do
+    [ 0, 65536 ].each do |port|
+      lambda {
+        dev_null { Forward::CLI.validate_port(port) }
+      }.must_raise SystemExit
+    end
+  end
+
+  it 'doesnt exit on valid cnames' do
+    [ 'foo.com', 'whatever-foo.com', 'www.foo.com', 'asdf.asdf.asdf.com' ].each do |cname|
+      Forward::CLI.validate_cname(cname).must_be_nil
+    end
+  end
+
+  it 'validates cname and exits if invalid' do
+    [ 'whatever', 'asdfasdf.', '-asdf', 'adsf#$).com' ].each do |cname|
+      lambda {
+        dev_null { Forward::CLI.validate_cname(cname) }
+      }.must_raise SystemExit
+    end
+  end
+
+  it 'doesnt exit on valid subdomains' do
+    [ 'foo', 'whatever-foo', 'asdf40' ].each do |subdomain|
+      Forward::CLI.validate_subdomain(subdomain).must_be_nil
+    end
+  end
+
+  it 'validates subdomain and exits if invalid' do
+    [ '-asdf', 'adsf#$)' ].each do |subdomain|
+      lambda {
+        dev_null { Forward::CLI.validate_subdomain(subdomain) }
+      }.must_raise SystemExit
+    end
+  end
+
+end

data/test/client_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+describe Forward::Client do
+
+  it 'should have access to api resources via the api method ' do
+
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+describe Forward::Config do
+
+  before :each do
+    @user_attributes = {
+      :id => '12345',
+      :api_token => 'abcdefg',
+      :private_key => 'secret'
+    }
+    FileUtils.mkdir_p(ENV['HOME'])
+  end
+
+  after :each do
+    if Forward::Config.present?
+      FileUtils.rm(Forward::Config::CONFIG_PATH)
+    end
+  end
+
+  it "initializes a config with a hash" do
+    config = Forward::Config.new(@user_attributes)
+
+    @user_attributes.each do |key, value|
+      config.send(key).must_equal value
+    end
+  end
+
+  it "updates a config with a hash" do
+    config = Forward::Config.new
+    config.update(@user_attributes)
+
+    @user_attributes.each do |key, value|
+      config.send(key).must_equal value
+    end
+  end
+
+  it "writes and reads a config from disk" do
+    config = Forward::Config.new(@user_attributes)
+    config.write
+
+    saved_config = Forward::Config.load
+
+    @user_attributes.each do |key, value|
+      saved_config.send(key).must_equal value
+    end
+  end
+
+  it "converts a config to a hash" do
+    config = Forward::Config.new(@user_attributes)
+    config_hash = config.to_hash
+
+    @user_attributes.each do |key, value|
+      config_hash[key].must_equal value
+    end
+  end
+
+  it "deletes config file" do
+    config = Forward::Config.new(@user_attributes)
+    config.write
+    Forward::Config.clear
+
+    Forward::Config.wont_be :present?
+  end
+
+  it "raises exception with an empty config" do
+    config = Forward::Config.new
+
+    lambda { config.validate }.must_raise Forward::ConfigError
+  end
+
+  it "raises exception with an invalid config" do
+    @user_attributes.delete(:api_token)
+    config = Forward::Config.new(@user_attributes)
+
+    lambda { config.validate }.must_raise Forward::ConfigError
+  end
+
+  it "raises exception with bad config on write" do
+    @user_attributes.delete(:private_key)
+    config = Forward::Config.new(@user_attributes)
+
+    lambda { config.write }.must_raise Forward::ConfigError
+  end
+
+  it "raises exception when a config file is not found" do
+    lambda { Forward::Config.load }.must_raise Forward::ConfigError
+  end
+
+  it "raises exception when reading bad config file" do
+    config_path = Forward::Config::CONFIG_PATH
+    config_data = 'the trash alone'
+
+    File.open(config_path, 'w') { |f| f.write(config_data) }
+
+    lambda { Forward::Config.read }.must_raise Forward::ConfigError
+  end
+
+  it "raises exception when an invalid config file is loaded" do
+    skip
+  end
+
+end