forward 0.3.3 → 1.0.0

data/test/config_test.rb

@@ -3,93 +3,142 @@ require 'test_helper'
 describe Forward::Config do
 
   before :each do
-    @config_attributes = {
-      :api_token => 'abcdefg',
-      :private_key => 'secret'
-    }
+    @config = Forward::Config
+
+    FakeFS.activate!
     FileUtils.mkdir_p(ENV['HOME'])
   end
 
   after :each do
-    FileUtils.rm(Forward::Config.config_path) if Forward::Config.present?
-    FileUtils.rm(Forward::Config.key_path) if Forward::Config.key_file_present?
+    FileUtils.rm_rf(ENV['HOME'])
+    FakeFS.deactivate!
   end
 
-  it "initializes a config with a hash" do
-    config = Forward::Config.new(@config_attributes)
-
-    @config_attributes.each do |key, value|
-      config.send(key).must_equal value
+  it "sets default config values" do
+    @config.set_defaults!
+    @config::DEFAULTS.each do |setting, value|
+      @config.send(setting).must_equal value
     end
   end
 
-  it "updates a config with a hash" do
-    config = Forward::Config.new
-    config.update(@config_attributes)
+  it "sets a default config value" do
+    @config.set_default!(:auto_open)
+    @config.auto_open.must_equal @config::DEFAULTS[:auto_open]
+  end
 
-    @config_attributes.each do |key, value|
-      config.send(key).must_equal value
-    end
+  it "has a windows config path if windows" do
+    Forward.expects(:windows?).returns(true)
+    @config.config_path.must_match /config\z/
+  end
+
+  it "has a non-windows config path if windows" do
+    Forward.expects(:windows?).returns(false)
+    @config.config_path.must_match /\.forwardrc\z/
   end
+  #
+  it "updates a config with a Hash" do
+    @config.set_defaults!
+    @config.update(auto_copy: false, auto_open: true)
 
-  it "writes and reads a config from disk" do
-    config = Forward::Config.new(@config_attributes)
-    config.write
+    @config.auto_copy.must_equal false
+    @config.auto_open.must_equal true
+  end
 
-    saved_config = Forward::Config.load
+  it "converts current config to a Hash" do
+    @config.set_defaults!
 
-    File.exist?(Forward::Config.config_path).must_equal true
-    File.exist?(Forward::Config.key_path).must_equal true
+    @config.to_hash.must_equal @config::DEFAULTS
+  end
 
-    @config_attributes.each do |key, value|
-      saved_config.send(key).must_equal value
-    end
+  it "knows if a config file is present" do
+      @config.wont_be :present?
+      FileUtils.touch(@config.config_path)
+      @config.must_be :present?
   end
 
-  it "only writes config values to the config file" do
-    config = Forward::Config.new(@config_attributes)
-    config.write
+  it "writes config to config file" do
+    @config.set_defaults!
 
-    config_file = File.read(Forward::Config.config_path)
-    config_file.include?('private_key').must_equal false
+    @config.wont_be :present?
+    @config.write
+    @config.must_be :present?
+    YAML.load_file(@config.config_path).must_equal @config::DEFAULTS
   end
 
-  it "converts a config to a hash" do
-    config = Forward::Config.new(@config_attributes)
-    config_hash = config.to_hash
+  it "loads a config file" do
+    File.open(@config.config_path, 'w') { |f|
+      f.write(YAML.dump(@config::DEFAULTS))
+    }
 
-    @config_attributes.each do |key, value|
-      config_hash[key].must_equal value
+    @config.must_be :present?
+    @config.load
+    @config::DEFAULTS.each do |setting, value|
+      @config.send(setting).must_equal value
     end
   end
 
-  it "raises exception with an empty config" do
-    config = Forward::Config.new
+  it "adds an initial account" do
+    @config.set_defaults!
+    account = { foo: '1234' }
+    subdomain, api_key = account.first
 
-    lambda { config.validate }.must_raise Forward::ConfigError
+    @config.add_account(subdomain, api_key)
+    @config.accounts.wont_be :empty?
+    @config.accounts.has_key?(subdomain).must_equal true
+    @config.default_account.must_equal subdomain
   end
 
-  it "raises exception with an invalid config" do
-    @config_attributes.delete(:api_token)
-    config = Forward::Config.new(@config_attributes)
+  it "removes an account and sets the default account to the next available" do
+    @config.set_defaults!
+    accounts = { foo: '1234', bar: '4321' }
 
-    lambda { config.validate }.must_raise Forward::ConfigError
+    accounts.each do |subdomain, api_key|
+      @config.add_account(subdomain, api_key)
+    end
+
+    @config.default_account.must_equal accounts.keys.last
+    @config.accounts.size.must_equal accounts.size
+
+    @config.remove_account(accounts.keys.last)
+
+    @config.accounts.size.must_equal accounts.size - 1
+    @config.default_account.must_equal accounts.keys.first
   end
 
-  # it "raises exception with bad config on write" do
-  #   @config_attributes.delete(:private_key)
-  #   config = Forward::Config.new(@config_attributes)
-  # 
-  #   lambda { config.write }.must_raise Forward::ConfigError
-  # end
+  it "removes the last account and sets default account to nil" do
+    @config.set_defaults!
+    account = { foo: '1234' }
+    subdomain, api_key = account.first
 
-  it "raises exception when a config file is not found" do
-    lambda { Forward::Config.load }.must_raise Forward::ConfigError
+    @config.add_account(subdomain, api_key)
+    @config.remove_account(subdomain)
+
+    @config.accounts.must_be :empty?
+    @config.default_account.must_be_nil
   end
 
-  it "raises exception when a key file is not found" do
-    File.open(Forward::Config.config_path, 'w') { |f| f.write YAML.dump(@config_attributes) }
-    lambda { Forward::Config.load }.must_raise Forward::ConfigError
+  it "sets the default account to an existing account" do
+    @config.set_defaults!
+
+    accounts        = { foo: '1234', bar: '4321' }
+    default_account = accounts.keys.last
+
+    accounts.each do |subdomain, api_key|
+      @config.add_account(subdomain, api_key)
+    end
+
+    @config.accounts.size.must_equal accounts.size
+    @config.set_default_account default_account
+    @config.default_account.must_equal default_account
+  end
+
+  it "gets the api token from the default account" do
+    @config.set_defaults!
+    account = { foo: '1234' }
+    subdomain, api_key = account.first
+
+    @config.add_account(subdomain, api_key)
+    @config.api_key.must_equal api_key
   end
 
 end

data/test/forward_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+describe Forward do
+
+  it 'should know what the host OS is' do
+    hosts = {
+      'mswin'  => :windows,
+      'mingw'  => :windows,
+      'cygwin' => :windows,
+      'darwin' => :osx,
+      'linux'  => :unix,
+      'bsd'    => :unix,
+      'foo'    => :unknown,
+    }
+
+    hosts.each do |name, kind|
+      RbConfig::CONFIG['host_os'] = name
+      Forward.instance_variable_set("@os", nil)
+      Forward.os.must_equal kind
+    end
+  end
+
+  it 'should know when the host OS is windows' do
+    RbConfig::CONFIG['host_os'] = 'mswin'
+    Forward.instance_variable_set("@os", nil)
+    Forward.must_be :windows?
+  end
+
+  it 'should set the log level to debug' do
+    Forward.debug!
+    Forward.logger.level.must_equal Logger::DEBUG
+  end
+
+  it 'should instantiate a logger' do
+    Forward.logger.must_be_instance_of ::Logger
+  end
+
+  it 'should produce a client string identfier' do
+    suppress_warnings do
+      RbConfig::CONFIG['host_os'] = 'darwin13.0.0'
+      RUBY_ENGINE                 = 'ruby'
+      RUBY_VERSION                = '2.0.0'
+
+      Forward.client_string.must_equal "(ruby-2.0.0)(darwin13.0.0)(v#{Forward::VERSION})"
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,41 +1,50 @@
-$LOAD_PATH.unshift(File.expand_path('../../test', __FILE__))
+$LOAD_PATH.unshift(File.expand_path('../', __FILE__))
 
 require 'rubygems'
+require 'fileutils'
 require 'yaml'
 require 'bundler'
 Bundler.setup
 
+require 'forward'
 require 'minitest/autorun'
 require 'minitest/pride'
-require 'fakefs'
-require 'fakeweb'
-require 'forward'
-require 'mocha'
+require 'mocha/mini_test'
+require 'webmock/minitest'
+require 'fakefs/safe'
+
+ENV['FORWARD_API_HOST'] = 'http://localhost'
 
-ENV['FORWARD_API_HOST'] = 'http://localhost:3000'
+Forward.logger = Logger.new('/dev/null')
 
-def dev_null(&block)
-  begin
-    orig_stdout = $stdout.dup
-    $stdout.reopen('/dev/null', 'w')
-    yield
-  ensure
-    $stdout.reopen(orig_stdout)
+WebMock.disable_net_connect!
+
+module Kernel
+  def dev_null(&block)
+    begin
+      orig_stdout = $stdout.dup
+      $stdout.reopen('/dev/null', 'w')
+      yield
+    ensure
+      $stdout.reopen(orig_stdout)
+    end
   end
-end
 
-def stub_api_request(action = :get, path = '/', options = {})
-  uri     = "#{Forward::Api.uri.host}:#{Forward::Api.uri.port}#{path}"
-  base_options = {
-    :status        => [ 200, 'OK' ],
-    'content-type' => 'application/json'
-  }
-
-  if options.is_a?(Array)
-    options.map! { |o| base_options.merge(o) }
-  else
-    options = base_options.merge(options)
+  def hash_to_forwardfile(hash)
+    yaml = YAML.dump(hash)
+    File.open('Forwardfile', 'w') { |f| f.write(yaml) }
   end
 
-  FakeWeb.register_uri(action, uri, options)
+  def suppress_warnings(&block)
+    original_verbosity = $VERBOSE
+    $VERBOSE           = nil
+    result             = yield
+    $VERBOSE           = original_verbosity
+
+    return result
+  end
+
+  def stop_reactor
+    EM.stop if EM.reactor_running?
+  end
 end

data/test/tunnel_test.rb

@@ -1,29 +1,57 @@
 require 'test_helper'
 
 describe Forward::Tunnel do
-
-  it "create a tunnel instance" do
-    tunnel_response = {
-      :_id => '1234',
-      :subdomain => 'foo',
-      :cname => 'foo.bar.com',
-      :vhost => '127.0.0.1',
-      :hostport => '3000',
-      :port => 20000,
-      :tunneler_public => 'test.forwardhq.com',
-      :timeout => 0
+  before :each do
+    @attributes = {
+      id:       '1234',
+      cname:    'foo.bar.com',
+      vhost:    '127.0.0.1',
+      hostport: '3000',
+      tunneler: 'test.forwardhq.com',
+      timeout:  0,
+      url: 'test.fwd.wf'
     }
+  end
+
+  it "creates a tunnel instance" do
+    tunnel = Forward::Tunnel.new(@attributes)
+
+    tunnel.id.must_equal @attributes[:id]
+    tunnel.cname.must_equal @attributes[:cname]
+    tunnel.host.must_equal @attributes[:vhost]
+    tunnel.port.must_equal @attributes[:hostport]
+    tunnel.tunneler.must_equal @attributes[:tunneler]
+    tunnel.timeout.must_equal @attributes[:timeout]
+
+    tunnel.requests.must_be :empty?
+    tunnel.wont_be :open?
+    tunnel.socket.wont_be_nil
+  end
+
+  it "knows if the tunnel is forwarding a directory/static" do
+    attributes = @attributes.dup
+    attributes[:static_path] = './'
+
+    tunnel = Forward::Tunnel.new(attributes)
+    tunnel.must_be :static?
+  end
+
+  it "knows if the tunnel is open" do
+    tunnel = Forward::Tunnel.new(@attributes)
+
+    tunnel.wont_be :open?
+    tunnel.instance_variable_set('@open', true)
+    tunnel.must_be :open?
+  end
+
+  it "displays an appopriate message when forwarding" do
+    attributes2 = @attributes.dup
+    attributes2[:static_path] = './'
+
+    tunnel  = Forward::Tunnel.new(@attributes)
+    tunnel2 = Forward::Tunnel.new(attributes2)
 
-    Forward::Api::Tunnel.expects(:create).returns(tunnel_response)
-    tunnel = Forward::Tunnel.new
-
-    tunnel.id.must_equal tunnel_response[:_id]
-    tunnel.subdomain.must_equal tunnel_response[:subdomain]
-    tunnel.cname.must_equal tunnel_response[:cname]
-    tunnel.vhost.must_equal tunnel_response[:vhost]
-    tunnel.hostport.must_equal tunnel_response[:hostport]
-    tunnel.port.must_equal tunnel_response[:port]
-    tunnel.tunneler.must_equal tunnel_response[:tunneler_public]
-    tunnel.timeout.must_equal tunnel_response[:timeout]
+    capture_io { tunnel.send(:display_ready_message) }.first.wont_match /directory/i
+    capture_io { tunnel2.send(:display_ready_message) }.first.must_match /directory/i
   end
 end