glowworm 0.3.0

data/test/integration/gemfile_for_specific_glowworm_version.lock

@@ -0,0 +1,55 @@
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.sv2/
+  remote: http://gems.us-east-1.ooyala.com:8080/
+  specs:
+    ansi (1.4.2)
+    ecology (0.0.18)
+      erubis
+      multi_json
+    erubis (2.7.0)
+    glowworm (0.0.22)
+      ecology (~> 0.0.12)
+      httparty
+      multi_json
+      termite (~> 0.0.13)
+      trollop
+    httparty (0.8.3)
+      multi_json (~> 1.0)
+      multi_xml
+    json (1.6.6)
+    metaclass (0.0.1)
+    minitap (0.3.3.1)
+      minitest
+      tapout (>= 0.3.0)
+    minitest (2.12.1)
+    mocha (0.11.3)
+      metaclass (~> 0.0.1)
+    multi_json (1.3.2)
+    multi_xml (0.4.4)
+    rainbow (1.1.4)
+    rake (0.9.2.2)
+    scope (0.2.3)
+      minitest
+    tapout (0.4.1)
+      ansi
+      json
+    termite (0.0.18)
+      ecology (~> 0.0.6)
+      multi_json
+      rainbow (~> 1.1.3)
+    trollop (1.16.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ansi
+  glowworm (= 0.0.22)
+  httparty
+  minitap (>= 0.3.3.1)
+  minitest
+  mocha
+  rake
+  scope
+  tapout

data/test/integration/integration_test_helper.rb

@@ -0,0 +1,153 @@
+#!/usr/bin/env ruby
+# This must be first, before anything else
+#require_relative "../glowworm_simplecov"
+
+require "nodule"
+require "nodule/util"
+require 'nodule/tempfile'
+require "scope"
+require "minitest/autorun"
+require "timeout"
+
+# use minitap if TAP output is requested
+if ENV["TAP_OUTPUT"] == "true"
+  require "minitap"
+end
+
+GLOWWORM_ROOT = File.join(File.dirname(__FILE__), "..", "..")
+GLOWWORM_SERVER_BIN="#{GLOWWORM_ROOT}/server/glowworm_server.rb"
+GLOWWORM_ECOLOGY_FILE = File.join(File.dirname(__FILE__), "server_test.ecology")
+GLOWWORM_TCP_PORT = 4999 # Nodule::Util.random_tcp_port
+GW_URI = "http://localhost:#{GLOWWORM_TCP_PORT}"
+
+def set_test_alarm(timeout=30)
+  Signal.trap("ALRM") do
+    assert false, "Timed out."
+    Thread.list.each { |t| t.kill unless t == Thread.current }
+    exit
+  end
+  LibC.alarm(timeout)
+end
+
+def cancel_test_alarm
+  LibC.alarm(0)
+end
+
+class Scope::TestCase
+  # The ruby distribution (version + gemset) to be used for the server
+  def server_ruby_dist
+    ENV["TEST_SERVER_RUBY_DIST"] || ENV["TEST_RUBY_DIST"] || "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+  end
+
+  # The ruby distribution (version + gemset) to be used for the client.
+  def client_ruby_dist
+    ENV["TEST_CLIENT_RUBY_DIST"] || ENV["TEST_RUBY_DIST"] || "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+  end
+
+  def cmd_in_server_ruby_dist(cmd, *args)
+    "eval \"$(rbenv init -)\" && rbenv shell #{server_ruby_dist} && bundle exec ruby #{cmd} " + args.join(' ')
+  end
+
+  def cmd_in_client_ruby_dist(cmd, *args)
+
+    # If no glowworm version is requested or the requested version is "latest" then execute ruby
+    # in the context of the client's bundle. This bundle is set up to include the lib directory
+    # in this case.
+    "eval \"$(rbenv init -)\" && rbenv shell #{client_ruby_dist} && bundle exec ruby #{cmd} " + args.join(' ')
+  end
+
+  def results_dir
+    # if RESULTS_DIR is defined place results under there. Otherwise place under test
+    out_path = ENV["RESULTS_DIR"] || File.join(GLOWWORM_ROOT, "test", "results")
+    Dir.mkdir out_path unless Dir.exists? out_path
+    out_path
+  end
+
+  def results_path(in_name)
+    File.join(results_dir, in_name)
+  end
+
+  def client_gemfile
+    if nil == ENV["TEST_GLOWWORM_VERSION"] || "latest" == ENV["TEST_GLOWWORM_VERSION"]
+      "#{GLOWWORM_ROOT}/Gemfile"
+    else
+      "#{GLOWWORM_ROOT}/test/integration/gemfile_for_specific_glowworm_version"
+    end
+  end
+  # starts a glowworm server along with the given tester. The tester cmd is executed by bash in the
+  # glowworm directory. The tester is expected to output TAP to STDOUT and all information messages
+  # to STDERR.
+  def start_tester_topology(tester_cmd, sec_to_sleep = 0, extra_server = {})
+
+      @hash = {
+        :greenio      => Nodule::Console.new(:fg => :green),
+        :redio        => Nodule::Console.new(:fg => :red),
+        :cyanio       => Nodule::Console.new(:fg => :cyan),
+        :yellowio     => Nodule::Console.new(:fg => :yellow),
+
+        :gw_nginx    => Nodule::Process.new(
+          "cp #{GLOWWORM_ROOT}/server/config/nginx.conf /tmp/glowworm-nginx.conf; nginx -c $PWD/test/integration/nginx.conf",
+          :stdout => :greenio, :stderr => :redio, :verbose => :cyanio
+        ),
+
+        :gw_server    => Nodule::Process.new(
+          { "ECOLOGY_SPEC" => GLOWWORM_ECOLOGY_FILE,
+            "GLOWWORM_SERVER_PORT" => GLOWWORM_TCP_PORT.to_s,
+            "GLOWWORM_ROOT" => GLOWWORM_ROOT },
+          *cmd_in_server_ruby_dist(GLOWWORM_SERVER_BIN),
+          :stdout => :greenio, :stderr => :capture, :verbose => :cyanio
+        ),
+
+        :gw_tester    => Nodule::Process.new(
+          { "RUBYOPT" => "-rubygems",
+            "ECOLOGY_SPEC" => GLOWWORM_ECOLOGY_FILE,
+            "GW_URI"  => GW_URI,
+            "BUNDLE_GEMFILE" => client_gemfile },
+          "bash", "-l", "-c", tester_cmd,
+          :stdout => :greenio, :verbose => :cyanio
+        )
+      }.merge! extra_server
+
+      @topology = Nodule::Topology.new( @hash )
+
+      @topology.start :gw_nginx
+
+    ([:gw_server] + extra_server.keys).each do |key|
+      @topology.start(key)
+      STDERR.puts "Starting #{key.to_s}"
+      begin
+        Timeout::timeout(60) do
+          elapsed = 0
+          while true
+            if key == :gw_server
+              break if @topology[key].stderr.any? do |line|
+                line["NEW_DATA"] || line["No new data"]
+              end
+            else
+              break if elapsed >= sec_to_sleep
+            end
+            sleep 0.01
+            elapsed = elapsed + 0.01
+
+            # failed to execute the command most likely
+            if @topology[key].done?
+              fail "could not start #{key.to_s}"
+            end
+          end
+        end
+      rescue Timeout::Error
+        fail "#{key.to_s} did not start in 60 seconds"
+      end
+    end
+
+    @topology.start_all
+    @topology[:gw_tester].waitpid(0)
+    @topology
+  end
+end
+
+# TODO(corey): This should output to a test specific tap file.
+if ENV["TAP_OUTPUT"] == "true"
+  MiniTest::Unit.runner = MiniTest::TapY.new
+end
+

data/test/integration/load_test.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "integration_test_helper")
+require "net/http"
+require 'multi_json'
+require "trollop"
+require "rainbow"
+
+LOAD_TESTER_BIN = "#{GLOWWORM_ROOT}/bin/load_tester"
+
+class LoadTest < Scope::TestCase
+  def run_tester(concurrent = 1, runs = 1, account = 123, feature = "foo")
+    @topology = nil
+    begin
+      tester_tapy = results_path('load_test.stdout')
+
+      tester_cmd = cmd_in_client_ruby_dist(LOAD_TESTER_BIN, "--account #{account} \
+          --feature #{feature} --server #{GW_URI} --fork true --concurrent #{concurrent} --runs #{runs} \
+          --header false | tee #{tester_tapy}")
+
+      @topology = start_tester_topology(tester_cmd)
+      tester_output = File.read(tester_tapy)
+    ensure
+      @topology.stop_all if nil != @topology
+
+      # TODO(noah): Hideous hack until we have real RVM/Nodule integration
+      system("pkill -9 -f glowworm_server.rb")
+    end
+    tester_output
+  end
+
+  setup_once do
+    system("ECOLOGY_SPEC=\"#{GLOWWORM_ECOLOGY_FILE}\" #{GLOWWORM_ROOT}/test/integration/create_sqlite_data.rb")
+    fail "Couldn't create SQLite data successfully!" unless $?.success?
+  end
+
+  context "with Glowworm server and tester" do
+    should "test server response for one process many requests" do
+      # TODO(jbhat): write the test to check @tester_output
+      puts "Running 1 process making 100 requests".color(:yellow)
+      tester_output = run_tester(1, 100)
+      puts tester_output.color(:magenta)
+    end
+
+    should "test server response for many processes one request" do
+      # TODO(jbhat): write the test to check @tester_output
+      puts "Running 100 process making 1 requests".color(:yellow)
+      tester_output = run_tester(100, 1)
+      puts tester_output.color(:magenta)
+    end
+
+    should "test server response for some processes and some stats" do
+      # TODO(jbhat): write the test to check @tester_output
+      puts "Running 10 process making 10 requests".color(:yellow)
+      tester_output = run_tester(10, 10)
+      puts tester_output.color(:magenta)
+    end
+  end
+end

data/test/integration/nginx.conf

@@ -0,0 +1,23 @@
+worker_processes  1;
+
+error_log  /tmp/glowworm-nginx-error.log;
+pid        /tmp/glowworm-nginx-nginx.pid;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    access_log  /tmp/glowworm-nginx-access.log;
+
+    sendfile        on;
+
+    keepalive_timeout  65;
+    tcp_nodelay        on;
+
+    gzip  on;
+    gzip_disable "MSIE [1-6]\.(?!.*SV1)";
+
+    include /tmp/glowworm-nginx.conf;
+}
+

data/test/integration/server_test.ecology.erb

@@ -0,0 +1,6 @@
+{
+  "application": "glowworm server, test version",
+  "db": { "adapter": "sqlite", "database": "<%= ENV["GLOWWORM_ROOT"] || "." %>/test_data.sqlite" },
+  "port": <%= ENV["GLOWWORM_SERVER_PORT"] || 4999 %>,
+  "features":  { "timeout": 10 }
+}

data/test/test_helper.rb

@@ -0,0 +1,47 @@
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :development)
+require "minitest/autorun"
+require "scope"
+
+# use minitap if TAP output is requested
+if ENV["TAP_OUTPUT"] == "true"
+  require "minitap"
+end
+
+# For testing Glowworm itself, use the local version *first*.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "glowworm"
+require "ecology/test_methods"
+
+class Scope::TestCase
+  include Ecology::Test
+
+  def mock_http_response(body, options = {})
+    options[:status] ||= 200
+    options[:server] ||= "http://fake-server.com"
+    options[:account] ||= "12345"
+    options[:feature] ||= "foo_feature"
+
+    response = mock "HTTP response"
+    response.expects(:code).returns(options[:status]).at_least_once
+    response.expects(:to_str).returns(body).at_least_once
+
+    expectation = RestClient.expects(:get).
+      with("#{options[:server]}/account/#{options[:account]}/#{options[:feature]}")
+
+    if options[:raise]
+      expectation.raises(RuntimeError)
+    else
+      expectation.returns(response).yields(response)
+    end
+  end
+
+end
+
+# TODO(corey): This should output to a test specific tap file.
+if ENV["TAP_OUTPUT"] == "true"
+  MiniTest::Unit.runner = MiniTest::TapY.new
+end
+

data/test/units/em_test.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+require "glowworm"
+
+class EmTest < Scope::TestCase
+  context "with an ecology and mocked server" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_TEXT
+{
+  "application": "foo_app",
+  "features": {
+    "server": "http://fake-server.com",
+    "refresh": 300,
+    "timeout": 5
+  }
+}
+ECOLOGY_TEXT
+
+      # Turn off loud logging for tests
+      Glowworm.termite_logger = stub("fake termite logger", :debug => nil, :info => nil, :warn => nil)
+
+      # @response = mock "HTTP response"
+      # @response.stubs(:headers).returns({ "last-modified" => "" })
+      # @response.stubs(:code).returns(200)
+      # HTTParty.stubs(:get).returns(@response)
+      Glowworm.stubs(:update_cache)
+    end
+
+    should "call the non-em-safe version of update cache when not in Glowworm.em" do
+      Glowworm.expects(:_update_cache_in_foreground_)
+      Glowworm.no_bg
+    end
+
+    should "call the em-safe version of update cache when in Glowworm.em" do
+      EM.expects(:synchrony)
+      Glowworm.stubs(:require_em)
+      Glowworm.em
+    end
+  end
+end

data/test/units/feature_flag_test.rb

@@ -0,0 +1,297 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper.rb")
+require "glowworm"
+
+class FeatureFlagTest < Scope::TestCase
+  context "with an ecology and mocked server" do
+    setup do
+      Ecology.reset
+
+      set_up_ecology <<ECOLOGY_TEXT
+{
+  "application": "foo_app",
+  "features": {
+    "server": "http://fake-server.com",
+    "refresh": 300,
+    "timeout": 5
+  }
+}
+ECOLOGY_TEXT
+
+      # Turn off loud logging for tests
+      Glowworm.termite_logger = stub("fake termite logger", :debug => nil, :info => nil, :warn => nil)
+
+      Ecology.read
+
+      @response = mock "HTTP response"
+      @response.stubs(:headers).returns({ "last-modified" => "" })
+    end
+
+    should "have a timeout of 5" do
+      assert_equal(5, Glowworm.timeout, "timeout will be 5 if the ecology is loaded correctly.")
+    end
+
+    should "return default with no connection and for weird query values" do
+      @response.expects(:code).returns(500).at_least_once
+      HTTParty.expects(:get).returns(@response)
+      assert_equal false, Glowworm.feature_flag("", "")
+      assert_equal false, Glowworm.feature_flag(12345, "foo_feature")
+
+      # Check long values
+      assert_equal false, Glowworm.feature_flag("*" * 10_000, "*" * 10_000)
+
+      # Check values that don't work
+      assert_raises RuntimeError do
+        assert_equal false, Glowworm.feature_flag("", nil)
+      end
+      assert_raises RuntimeError do
+        assert_equal false, Glowworm.feature_flag(nil, "")
+      end
+      assert_raises RuntimeError do
+        assert_equal false, Glowworm.feature_flag(nil, nil)
+      end
+    end
+
+    should "call HTTP GET on the first query to feature_flag" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      Glowworm.feature_flag(12345, "foo_feature")
+    end
+
+    should "return true when feature is set for account_set" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal true, Glowworm.feature_flag(12345, "foo_feature")
+    end
+
+    should "return true if there is only an override" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.stubs(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  },
+  "overrides" : {
+    "foo_feature": { "12345" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal true, Glowworm.feature_flag(12345, "foo_feature")
+    end
+
+    should "return false for otherwise-active feature if there is an override" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.stubs(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  },
+  "overrides" : {
+    "foo_feature": { "12345" : 0 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal false, Glowworm.feature_flag(12345, "foo_feature", :default => true)
+    end
+
+    should "return false if both override and account_set say so" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.stubs(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "overrides" : {
+    "foo_feature": { "12345" : 0 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal false, Glowworm.feature_flag(12345, "foo_feature", :default => true)
+    end
+
+    should "return true if both override and account_set say so" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.stubs(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  },
+  "overrides" : {
+    "foo_feature": { "12345" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal true, Glowworm.feature_flag(12345, "foo_feature")
+    end
+
+    should "return a value if option is get_value" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.stubs(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 2 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      assert_equal 2, Glowworm.feature_value(12345, "foo_feature", :get_value => true)
+    end
+
+    should "call HTTP GET again if TTL is 0" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).times(5).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      Glowworm.feature_flag(12345, "foo_feature")
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 0.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 0.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 0.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 0.0)
+    end
+
+    should "call HTTP GET again if TTL is less than 0" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).times(5).with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      Glowworm.feature_flag(12345, "foo_feature")
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => -10.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => -10.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => -10.0)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => -10.0)
+    end
+
+    should "not call HTTP GET again if TTL is very high" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).once.with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      Glowworm.feature_flag(12345, "foo_feature")
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 10_000)
+    end
+
+    should "call HTTP GET again after TTL time is up" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).twice.with("http://fake-server.com/all_if_modified", anything).
+        returns(@response)
+      initial_time = Time.now
+      Glowworm.feature_flag(12345, "foo_feature")
+
+      # Stub Time.now to return the first time plus ten seconds
+      Time.expects(:now).at_least_once.returns(initial_time + 10.0)
+
+      # Then make sure we do another HTTP get afterward
+      Glowworm.feature_flag(12345, "foo_feature", :ttl => 8.0)
+    end
+
+    should "not wait for HTTP request with timeout 0" do
+      # May or may not get called, depending on timing
+      @response.stubs(:code).returns(500)
+      HTTParty.stubs(:get).returns(@response)
+
+      # Expect and then simulate a 0-second join
+      Thread.any_instance.expects(:join).with(0.0).returns(false)
+
+      Glowworm.feature_flag(12345, "foo_feature", :timeout => 0.0)
+    end
+
+=begin
+    should "update cached value later for HTTP request with timeout 1.0" do
+      @response.expects(:code).returns(200).at_least_once
+      @response.expects(:body).returns(<<JSON).at_least_once
+{
+  "version": 1,
+  "account_sets": { "12345": [ "1" ] },
+  "features" : {
+    "foo_feature": { "1" : 1 }
+  }
+}
+JSON
+      HTTParty.expects(:get).with("http://fake-server.com/all_if_modified").
+        returns(@response)
+
+      # Expect and then simulate a 1-second join that timed out
+      Thread.any_instance.expects(:join).with(1.0).returns(false)
+
+      # But require that the cache update still get called
+      Glowworm.expects(:refresh_cache_from_response)
+
+      Glowworm.feature_flag(12345, "foo_feature", :timeout => 1.0)
+
+      # Give the background thread time to rejoin
+      sleep 0.25
+    end
+=end
+  end
+end