forward 0.3.3 → 1.0.0

data/test/api/resource_test.rb

@@ -1,82 +1,98 @@
 require 'test_helper'
 
-describe Forward::Api::Resource do
-  Api = Forward::Api
-
+describe Forward::API::Resource do
   before :each do
-    Api.token = 'abc123'
+    Forward::Config.accounts = { foo: 'abc123' }
+    Forward::Config.default_account = :foo
   end
 
   it 'builds http requests based on given method' do
-    resource     = Api::Resource.new
-    resource.uri = '/path'
+    resource = Forward::API::Resource.new
 
-    [ :get, :post, :put, :delete ].each do |method|
-      resource.build_request(method)
-      klass   = eval("Net::HTTP::#{method.capitalize}")
-      request = resource.instance_variable_get('@request')
+    [ :get, :post, :delete ].each do |method|
+      options = {}
 
-      request.kind_of?(klass).must_equal true
+      resource.expects(:request).with(method, options)
+      resource.send(method, options)
     end
   end
 
-  it 'builds http requests with json bodies' do
-    resource     = Api::Resource.new
-    resource.uri = '/path'
+  it "adds json headers to every request" do
+    resource = Forward::API::Resource.new
+    headers  = {
+      'Accept'       => 'application/json',
+      'Content-Type' => 'application/json'
+    }
 
-    [ :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')
+    stub_request(:get, 'localhost/').
+      with(headers: headers).
+      to_return(status: 200)
 
-      request.kind_of?(klass).must_equal true
-      request.body.must_equal params.to_json
-    end
+    EM.run_block {
+      Forward::API::Resource.new.get(path: '/') {}
+    }
   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'
+  it "adds auth header if request is authenticated" do
+    resource = Forward::API::Resource.new
+    headers  = {
+      'Accept'        => 'application/json',
+      'Authorization' => 'Token token=abc123',
+      'Content-Type'  => 'application/json'
+    }
+
+    stub_request(:get, 'localhost/').
+      with(headers: headers).
+      to_return(status: 200)
+
+    EM.run_block {
+      Forward::API::Resource.new.get(path: '/', authenticated: true) {}
+    }
   end
 
+  it "adds a json body if params given" do
+    resource = Forward::API::Resource.new
+    params   = { foo: 'bar' }
 
-  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)
+    stub_request(:post, 'localhost/').
+      with(body: params.to_json).
+        to_return(status: 200)
 
-    lambda { resource.parse_response(response) }.must_raise Api::BadResponse
+    EM.run_block {
+      Forward::API::Resource.new.post(path: '/', params: params) {}
+    }
   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')
+  it "exits with message if status is 401" do
+    resource = Forward::API::Resource.new
+
+    stub_request(:get, 'localhost/').
+      to_return(status: 401)
 
-    lambda { resource.parse_response(response) }.must_raise Api::BadResponse
+    out, err = capture_io do
+      begin
+        EM.run_block {
+          Forward::API::Resource.new.get(path: '/') {}
+        }
+      rescue SystemExit; end
+    end
+    out.must_match /Unable to authenticate/i
   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" }')
+  it "exits with message if response is invalid JSON" do
+    resource = Forward::API::Resource.new
+
+    stub_request(:get, 'localhost/').
+      to_return(status: 200, body: '{"foo"}')
 
-    json = resource.parse_response(response)
-    json.kind_of?(Hash).must_equal true
-    json[:foo].must_equal 'bar'
+    out, err = capture_io do
+      begin
+        EM.run_block {
+          Forward::API::Resource.new.get(path: '/') {}
+        }
+      rescue SystemExit; end
+    end
+    out.must_match /Unable to connect to API/i
   end
 
 end

data/test/api/tunnel_test.rb

@@ -1,90 +1,89 @@
 require 'test_helper'
 
-describe Forward::Api::Tunnel do
+describe Forward::API::Tunnel do
 
   before :each do
-    FakeWeb.allow_net_connect = false
-    Forward::Api.token      = 'abc123'
+    Forward::Config.accounts = { foo: 'abc123' }
+    Forward::Config.default_account = :foo
   end
 
   it "creates a tunnel and returns the attributes" do
-    fake_body = { :tunnel => { :_id => '1', :subdomain => 'foo', :port => 56789 }}
-
-    stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json)
+    tunnel_options = { port: '3000', host: 'localhost' }
+    params         = {
+      hostport: tunnel_options[:port],
+      vhost: tunnel_options[:host],
+      subdomain: nil, cname: nil,
+      username: nil, password: nil, no_auth: nil,
+      client: Forward.client_string,
+    }
+    body = { tunnel: { _id: '1', subdomain: 'foo', port: 56789 }}
 
-    response = Forward::Api::Tunnel.create(:port => 3000)
+    stub_request(:post, 'localhost/api/v3/tunnels/').
+      with(body: params.to_json).
+      to_return(status: 200, body: body.to_json)
 
-    response[:_id].must_equal fake_body[:tunnel][:_id]
-    response[:subdomain].must_equal fake_body[:tunnel][:subdomain]
-    response[:port].must_equal fake_body[:tunnel][:port]
+    EM.run_block {
+      Forward::API::Tunnel.create(tunnel_options) do |tunnel|
+        tunnel[:id].must_equal body[:id]
+        tunnel[:subdomain].must_equal body[:subdomain]
+        tunnel[:port].must_equal body[:port]
+      end
+    }
   end
 
-  it "exits with message if create response is a resource_error" do
-    fake_body = {
-      :type => 'resource_error',
-      :errors => {
-        :base => [ 'did not work '],
-        :subdomain => [ 'is invalid', 'is too short' ]
-      }
-    }
+  it "exits with message on 422" do
+    tunnel_options = { port: '3000', host: 'localhost' }
 
-    stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+    stub_request(:post, 'localhost/api/v3/tunnels/').
+      to_return(status: 422)
 
     out, err = capture_io do
       begin
-        Forward::Api::Tunnel.create(:port => 3000)
+        EM.run_block {
+          Forward::API::Tunnel.create(tunnel_options) { }
+        }
       rescue SystemExit; end
     end
-    out.must_match /did not work/i
-    out.must_match /subdomain is invalid/i
-    out.must_match /subdomain is too short/i
+    out.must_match /unable to allocate tunnel/i
   end
 
-  it "exits with message if trial has expired" do
-     fake_body = {
-       :type => 'trial_expired',
-       :message => 'your trial has expired'
+  it "exits with message and displays account errors" do
+     tunnel_options = { port: '3000', host: 'localhost' }
+     body = {
+       type: 'account_error',
+       errors: { account: ['Trial has expired'] }
      }
 
-     stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+     stub_request(:post, 'localhost/api/v3/tunnels/').
+       to_return(status: 422, body: body.to_json)
 
      out, err = capture_io do
        begin
-         Forward::Api::Tunnel.create(:port => 3000)
+         EM.run_block {
+           Forward::API::Tunnel.create(tunnel_options) { }
+         }
        rescue SystemExit; end
      end
      out.must_match /trial has expired/i
    end
 
-   it "exits with message if account has been suspended" do
-      fake_body = {
-        :type => 'account_suspended',
-        :message => 'your account has been suspended due for failed payment'
+   it "exits with message on bad tunnel data" do
+      tunnel_options = { port: '3000', host: 'localhost' }
+      body = {
+        type: 'invalid_request_error'
       }
 
-      stub_api_request(:post, '/api/v2/tunnels', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+      stub_request(:post, 'localhost/api/v3/tunnels/').
+        to_return(status: 422, body: body.to_json)
 
       out, err = capture_io do
         begin
-          Forward::Api::Tunnel.create(:port => 3000)
+          EM.run_block {
+            Forward::API::Tunnel.create(tunnel_options) { }
+          }
         rescue SystemExit; end
       end
-      out.must_match /account has been suspended/i
+      out.must_match /invalid tunnel parameters/i
     end
 
-  it "gives a choice and closes a tunnel if limit is reached" do
-     post_options = [
-       { :body => { :type => 'tunnel_limit_reached', :message => 'you have reached your limit' }.to_json, :status => [ 422, 'Unprocessable Entity' ] },
-       { :body => { :tunnel => { :_id => '1', :subdomain => 'foo', :port => 56789 } }.to_json }
-     ]
-     index_body = { :tunnels => [ { :_id => 'abc123', :hostport => 1234 }, { :_id => 'def456', :hostport => 1235 } ] }
-
-     stub_api_request(:post, '/api/v2/tunnels', post_options)
-     stub_api_request(:get, '/api/v2/tunnels', :body => index_body.to_json)
-     STDIN.expects(:gets).returns('1')
-     Forward::Api::Tunnel.expects(:destroy).with(index_body[:tunnels].first[:_id])
-
-     dev_null { Forward::Api::Tunnel.create(:port => 3000) }
-   end
-
 end

data/test/api/user_test.rb

@@ -1,41 +1,54 @@
 require 'test_helper'
 
-describe Forward::Api::User do
-
-  before :each do
-    FakeWeb.allow_net_connect = false
-  end
+describe Forward::API::User do
 
   it "retrieves the users api token and returns it" do
-    fake_body = { :user => { :api_token => '123abc' } }
-
-    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json)
-
-    response = Api::User.api_token('guy@example.com', 'secret')
-    response[:api_token].must_equal '123abc'
+    params = { email: 'guy@example.com', password: 'secret' }
+    body   = { subdomain: 'fooco', token: '123abc' }
+
+    stub_request(:post, 'localhost/api/v3/user/token').
+      with(body: params.to_json).
+      to_return(status: 200, body: body.to_json)
+
+    EM.run_block {
+      Forward::API::User.authenticate(params[:email], params[:password]) do |subdomain, token|
+        token.must_equal '123abc'
+      end
+    }
   end
 
   it "exits with message if authentication fails" do
-    fake_body = { :type => 'api_error' }
+    params = { email: 'guy@example.com', password: 'secret' }
 
-    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json, :status => [ 401, 'Authentication Failed' ])
+    stub_request(:post, 'localhost/api/v3/user/token').
+      with(body: params.to_json).
+      to_return(status: 401)
 
     out, err = capture_io do
       begin
-        Api::User.api_token('guy@example.com', 'secret')
+        EM.run_block {
+          Forward::API::User.authenticate(params[:email], params[:password]) {}
+        }
       rescue SystemExit; end
     end
-    out.must_match /unable to authenticate/i
+    out.must_match /Unable to authenticate/i
   end
 
   it "exits with message if response has errors" do
-    fake_body = { :type => 'api_error' }
+    params = { email: 'guy@example.com', password: 'secret' }
 
-    stub_api_request(:post, '/api/v2/users/api_token', :body => fake_body.to_json, :status => [ 422, 'Unprocessable Entity' ])
+    stub_request(:post, 'localhost/api/v3/user/token').
+      with(body: params.to_json).
+      to_return(status: 422)
 
-    lambda { 
-      dev_null { Api::User.api_token('guy@example.com', 'secret') }
-    }.must_raise SystemExit
+    out, err = capture_io do
+      begin
+        EM.run_block {
+          Forward::API::User.authenticate(params[:email], params[:password]) {}
+        }
+      rescue SystemExit; end
+    end
+    out.must_match /Unable to authenticate/i
   end
 
 end

data/test/cli_test.rb

@@ -2,130 +2,4 @@ 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 'exits if username is invalid' do
-    [ 'foo ', ' asdfasdf ', 'fooo bar' ].each do |username|
-      lambda {
-        dev_null { Forward::CLI.validate_username(username) }
-      }.must_raise SystemExit
-    end
-  end
-
-  it 'validates a good username' do
-    [ 'foo', 'asdflkj3r&)(#@#)', 'DF#R::#SFSDF' ].each do |username|
-      Forward::CLI.validate_username(username).must_be_nil
-    end
-  end
-
-  it 'exits if password is invalid' do
-    [ 'foo ', ' asdfasdf ', 'fooo bar' ].each do |password|
-      lambda {
-        dev_null { Forward::CLI.validate_password(password) }
-      }.must_raise SystemExit
-    end
-  end
-
-  it 'validates a good password' do
-    [ 'foo', 'asdflkj3r&)(#@#)', 'DF#R::#SFSDF' ].each do |password|
-      Forward::CLI.validate_password(password).must_be_nil
-    end
-  end
-
-  it 'parses a Forwardfile' do
-    hash_to_forwardfile(:auth => 'username:password')
-
-    options = Forward::CLI.parse_forwardfile
-    options.has_key?(:auth).must_equal true
-  end
-
-  it 'exits if a Forwardfile does not parse to a Hash' do
-    hash_to_forwardfile('username:password')
-
-    lambda {
-      dev_null { Forward::CLI.parse_forwardfile }
-    }.must_raise SystemExit
-  end
-
-  it 'overloads Forwardfile options via commandline options' do    
-    hash_to_forwardfile(
-      :port             => 8000, 
-      :username         => 'username', 
-      :password         => 'password', 
-      :subdomain_prefix => 'foo'
-    )
-    args    = [ '3000', '-a', 'example:secret', 'bar' ]
-    options = Forward::CLI.parse_args_and_options(args)
-
-    options[:port].must_equal 3000
-    options[:username].must_equal 'example'
-    options[:password].must_equal 'secret'
-    options[:subdomain_prefix].must_equal 'bar'
-  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 prefix' do
-    [ 'foo', 'whatever-foo', 'asdf40' ].each do |subdomain|
-      Forward::CLI.validate_subdomain_prefix(subdomain).must_be_nil
-    end
-  end
-
-  it 'validates subdomain prefix and exits if invalid' do
-    [ '-asdf', 'adsf#$)' ].each do |subdomain|
-      lambda {
-        dev_null { Forward::CLI.validate_subdomain_prefix(subdomain) }
-      }.must_raise SystemExit
-    end
-  end
-
-end
-
-def hash_to_forwardfile(hash)
-  yaml = YAML.dump(hash)
-  File.open('Forwardfile', 'w') { |f| f.write(yaml) }
 end

data/test/command/account_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+describe Forward::Command::Account do
+  before :each do
+    FakeFS.activate!
+    FileUtils.mkdir_p(ENV['HOME'])
+  end
+
+  after :each do
+    FileUtils.rm_rf(ENV['HOME'])
+    FakeFS.deactivate!
+  end
+
+  it "logs a client in with a provided email" do
+    email    = 'foo@example.com'
+    password = 'bar'
+    command  = Forward::Command::Account.new({}, [email])
+
+    Forward::API::User.expects(:authenticate).with(email, password)
+    command.expects(:ask_for_credentials).with(email).returns([email, password])
+
+    EM.run_block {
+      command.login
+    }
+  end
+end

data/test/command/tunnel_test.rb

@@ -0,0 +1,133 @@
+require 'test_helper'
+
+describe Forward::Command::Tunnel do
+  before :each do
+    FakeFS.activate!
+    FileUtils.mkdir_p(ENV['HOME'])
+  end
+
+  after :each do
+    FileUtils.rm_rf(ENV['HOME'])
+    FakeFS.deactivate!
+  end
+
+  it 'parses a forwarded port' do
+    command = Forward::Command::Tunnel.new({}, ['600'])
+
+    command.send(:parse_forwarded)
+    command.options[:port].must_equal 600
+  end
+
+  it 'parses a forwarded host' do
+    command = Forward::Command::Tunnel.new({}, ['mysite.dev'])
+
+    command.send(:parse_forwarded)
+    command.options[:host].must_equal 'mysite.dev'
+  end
+
+  it 'parses a forwarded host and port' do
+    command = Forward::Command::Tunnel.new({}, ['mysite.dev:8888'])
+
+    command.send(:parse_forwarded)
+    command.options[:host].must_equal 'mysite.dev'
+    command.options[:port].must_equal 8888
+  end
+
+  it 'exits if auth pair is invalid' do
+    [ 'as:df:asdf', 'fooo bar', 'foo oo:bar' ].each do |auth|
+      lambda {
+        dev_null {
+          command = Forward::Command::Tunnel.new(auth: auth)
+          command.send(:validate_auth)
+        }
+      }.must_raise Forward::CLIError
+    end
+  end
+
+  it 'validates a auth pair' do
+    [ 'foo:asdflkj3r&)', 'tom:#SFSDF' ].each do |auth|
+      command = Forward::Command::Tunnel.new(auth: auth)
+      command.send(:validate_auth)
+    end
+  end
+
+  it 'parses a Forwardfile' do
+    hash_to_forwardfile(auth: 'username:password')
+
+    command = Forward::Command::Tunnel.new
+    command.send(:parse_forwardfile)
+    command.options[:auth].must_equal 'username:password'
+  end
+
+  it 'exits if a Forwardfile does not parse to a Hash' do
+    hash_to_forwardfile('username:password')
+
+    lambda {
+      dev_null { Forward::Command::Tunnel.new.send(:parse_forwardfile) }
+    }.must_raise SystemExit
+  end
+
+  it 'overloads Forwardfile options via commandline options' do
+    hash_to_forwardfile(
+      port:             8000,
+      username:         'username',
+      password:         'password',
+      subdomain_prefix: 'foo'
+    )
+
+    EM.expects(:run)
+
+    command = Forward::Command::Tunnel.new({auth: 'example:secret'}, ['3000', 'bar'])
+    command.start
+
+    command.options[:port].must_equal 3000
+    command.options[:username].must_equal 'example'
+    command.options[:password].must_equal 'secret'
+    command.options[:subdomain_prefix].must_equal 'bar'
+  end
+
+  it 'validates port and exits if invalid' do
+    command         = Forward::Command::Tunnel.new
+    command.options = { port: 3000 }
+
+    command.send(:validate_port)
+
+    [ 0, 65536 ].each do |port|
+      lambda {
+        dev_null {
+          command.options[:port] = port
+          command.send(:validate_port) }
+      }.must_raise Forward::CLIError
+    end
+  end
+
+  it 'validates cname and exits if invalid' do
+    command         = Forward::Command::Tunnel.new
+    command.options = { cname: 'foo.bar.com' }
+
+    command.send(:validate_cname)
+    [ 'whatever', 'asdfasdf.', '-asdf', 'adsf#$).com' ].each do |cname|
+      lambda {
+        dev_null {
+          command.options[:cname] = cname
+          command.send(:validate_cname)
+        }
+      }.must_raise Forward::CLIError
+    end
+  end
+
+  it 'validates subdomain prefix and exits if invalid' do
+    command         = Forward::Command::Tunnel.new
+    command.options = { subdomain_prefix: 'foo' }
+
+    command.send(:validate_subdomain_prefix)
+    [ '-asdf', 'adsf#$)' ].each do |subdomain|
+      lambda {
+        dev_null {
+          command.options[:subdomain_prefix] = subdomain
+          command.send(:validate_subdomain_prefix)
+        }
+      }.must_raise Forward::CLIError
+    end
+  end
+end