glowworm 0.3.0

data/server/run/server.sh

@@ -0,0 +1,7 @@
+#!/bin/bash -e
+
+APP_ROOT=/opt/ooyala/glowworm/current
+
+cd $APP_ROOT && \
+source $APP_ROOT/config/pushed_environment.rb && \
+/opt/ruby/1.9/bin/bundle exec /opt/ruby/1.9/bin/ruby glowworm_server.rb 2>&1 |cronolog --symlink=$SHARED_PATH/log/current $SHARED_PATH/log/glowworm.log.%Y-%m-%d

data/server/server_test.rb

@@ -0,0 +1,72 @@
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :development)
+require "minitest/autorun"
+
+# For testing Glowworm itself, use the local version *first*.
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+require "glowworm"
+
+class Scope::TestCase
+  def set_up_ecology(file_contents, filename = "some.ecology")
+    ENV["ECOLOGY_SPEC"] = filename
+    File.expects(:exist?).with(filename).returns(true)
+    File.expects(:read).with(filename).returns(file_contents)
+  end
+end
+
+class GlowwormServerTest < Scope::TestCase
+  def mock_sequel_query(mock_db, name, data)
+    data_stub = stub(:all => data) do
+      stubs(:select).returns(self)
+      stubs(:filter).returns(self)
+      stubs(:join).returns(self)
+      stubs(:right_join).returns(self)
+    end
+    mock_db.stubs(:[]).with(name).returns(data_stub)
+
+    # Yield each line of data in turn when somebody calls .each
+    data[1..-1].inject(mock_db.stubs(:each).yields(data[0])) do |expectation, data_item|
+      expectation.then.yields(data_item)
+    end
+  end
+
+  setup do
+    set_up_ecology <<JSON
+{
+  "application": "Glowworm Server Test",
+  "features": {
+  }
+}
+JSON
+  end
+
+  context "with mocked test data" do
+    setup do
+      @mock_db = mock("Sequel Database object")
+      Sequel.expects(:connect).returns(@mock_db)
+      @logger_mock = mock("Termite logger")
+      @logger_mock.stubs(:warn => nil, :info => nil, :debug => nil)
+      Termite::Logger.expects(:new).returns(@logger_mock)
+    end
+
+    should "Return results for all accounts and features" do
+      mock_sequel_query(@mock_db, :account_set_accounts,
+                        [
+                         {:account => "123", :account_set_id => 1},
+                         {:account => "456", :account_set_id => 2},
+                        ])
+      mock_sequel_query(@mock_db, :account_set_features,
+                        [
+                         {:name => "foo_feature", :account_set_id => 1}
+                        ])
+      mock_sequel_query(@mock_db, :feature_account_overrides,
+                        [
+                         {:name => "foo_feature", :account => "456", :value => true}
+                        ])
+
+      assert true
+    end
+  end
+end

data/server/version.rb

@@ -0,0 +1,3 @@
+module Glowworm
+  VERSION = "0.3.0"
+end

data/test/integration/basic_server_test.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "integration_test_helper")
+require "net/http"
+require 'multi_json'
+require "trollop"
+require "psych"
+
+BASIC_SERVER_TESTER_BIN="#{GLOWWORM_ROOT}/bin/basic_server_tester"
+
+class BasicServerTest < Scope::TestCase
+  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
+    setup_once do
+      tester_tapy = results_path('basic_server_test.yaml')
+
+      # The tester command outputs results via TAP-Y and diagnostics to STDERR
+      tester_cmd = cmd_in_client_ruby_dist(BASIC_SERVER_TESTER_BIN, "--server #{GW_URI} | tee #{tester_tapy}")
+      @topology = start_tester_topology(tester_cmd)
+
+      STDERR.puts "tester status #{@topology[:gw_tester].status}"
+
+      @tester_results = Psych.parse_stream(IO.read(tester_tapy)).to_ruby
+    end
+
+    teardown_once do
+      @topology.stop_all
+
+      # TODO(noah): Hideous hack until we have real RVM/Nodule integration
+      system("pkill -9 -f glowworm_server.rb")
+    end
+
+    should "test server response" do
+      contained_summary = false
+      @tester_results.each do |tap_entry|
+        if "final" == tap_entry["type"]
+          contained_summary = true
+          counts = tap_entry["counts"]
+
+          assert_equal(0, counts["fail"], "tester should have no assertion failures")
+          assert_equal(0, counts["error"], "tester should not have encountered any errors")
+          assert(counts["total"] > 0, "tester should have performed at least a single test")
+        end
+      end
+
+      assert(contained_summary, "the tester must have produced a complete output stream")
+    end
+  end
+
+  context "with Glowworm server and threadless tester" do
+    setup_once do
+      tester_tapy = results_path('basic_server_nbg_test.yaml')
+
+      # The tester command outputs results via TAP-Y and diagnostics to STDERR
+      tester_cmd = cmd_in_client_ruby_dist(BASIC_SERVER_TESTER_BIN, "--server #{GW_URI} --nbg true | tee #{tester_tapy}")
+      @topology = start_tester_topology(tester_cmd)
+
+      STDERR.puts "tester status #{@topology[:gw_tester].status}"
+
+      @tester_results = Psych.parse_stream(IO.read(tester_tapy)).to_ruby
+    end
+
+    teardown_once do
+      @topology.stop_all
+
+      # TODO(noah): Hideous hack until we have real RVM/Nodule integration
+      system("pkill -9 -f glowworm_server.rb")
+    end
+
+    should "test server response" do
+      contained_summary = false
+      @tester_results.each do |tap_entry|
+        if "final" == tap_entry["type"]
+          contained_summary = true
+          counts = tap_entry["counts"]
+
+          assert_equal(0, counts["fail"], "tester should have no assertion failures")
+          assert_equal(0, counts["error"], "tester should not have encountered any errors")
+          assert(counts["total"] > 0, "tester should have performed at least a single test")
+        end
+      end
+
+      assert(contained_summary, "the tester must have produced a complete output stream") unless ENV["TEST_GLOWWORM_VERSION"].nil? || ENV["TEST_GLOWWORM_VERSION"] < "0.1.6"
+    end
+  end
+end

data/test/integration/create_sqlite_data.rb

@@ -0,0 +1,196 @@
+#!/usr/bin/env ruby
+
+require "ecology"
+require "sequel"
+require "termite"
+
+# Can be overridden with ECOLOGY_SPEC
+Ecology.read("glowworm_server.ecology")
+
+db_spec = Ecology.property("db") || { :adapter => 'sqlite', :database => 'test_data.sqlite' }
+STDERR.puts "Connecting to #{db_spec.inspect}"
+DB = Sequel.connect db_spec
+MyLogger = Termite::Logger.new
+
+# The table creation below duplicates a lot of stuff from
+# server/db_migrations.  Alas.
+
+DB.create_table!(:account_sets) do
+  primary_key :id
+  Datetime :created_at, :null => false
+  Datetime :updated_at, :null => false
+  String :name, :null => false
+  String :description
+  index :name, :unique => true
+end
+
+DB.create_table!(:features) do
+  primary_key :id
+  Datetime :created_at, :null => false
+  Datetime :updated_at, :null => false
+  String :name, :null => false
+  String :description
+  Boolean :fully_active, :default => false
+  index :name, :unique => true
+end
+
+DB.create_table!(:account_set_accounts) do
+  primary_key :id
+  Datetime :added_at, :null => false
+  Integer :account_set_id, :null => false
+  Integer :provider_id, :null => true
+  String :account, :limit => 10, :null => false
+  index :account_set_id
+  index :provider_id
+  index :account
+  index [:account_set_id, :account], :unique => true
+end
+
+DB.create_table!(:account_set_features) do
+  primary_key :id
+  Datetime :added_at, :null => false
+  Integer :account_set_id, :null => false
+  Integer :feature_id, :null => false
+  Integer :value, :null => false, :default => 1
+  index :feature_id
+  index [:account_set_id, :feature_id], :unique => true
+end
+
+DB.create_table!(:feature_account_overrides) do
+  Integer :provider_id, :null => true
+  String :account, :limit => 10, :null => false
+  Integer :feature_id, :null => false
+  Integer :value, :null => false
+  index :provider_id
+  index :feature_id
+  index [:account, :feature_id], :unique => true
+end
+
+# Probably gone already, but let's be sure.
+DB[:account_sets].delete
+DB[:features].delete
+DB[:account_set_accounts].delete
+DB[:account_set_features].delete
+DB[:feature_account_overrides].delete
+
+def unique_id
+  @id_counter ||= 10_000
+  @id_counter += 1
+  @id_counter
+end
+
+# "Hello, world" for features - feature_flag(123, "foo") should return true.
+FOO_FEATURE = 1
+DB[:features].insert(:id => FOO_FEATURE, :name => "foo", :description => "hello world feature",
+                     :created_at => Time.now, :updated_at => Time.now)
+DB[:feature_account_overrides].insert(:account => "123", :provider_id => 123, :feature_id => FOO_FEATURE,
+                                      :value => 1)
+
+# Accounts sets for basic testing
+ONE_HORSE_TOWN = 1
+DB[:account_sets].insert(:id => ONE_HORSE_TOWN, :name => "solo", :description => "one-horse town",
+                         :created_at => Time.now, :updated_at => Time.now)
+TWO_HORSE_TOWN = 2
+DB[:account_sets].insert(:id => TWO_HORSE_TOWN, :name => "duo", :description => "two-horse town",
+                         :created_at => Time.now, :updated_at => Time.now)
+NO_HORSE_TOWN = 3
+DB[:account_sets].insert(:id => NO_HORSE_TOWN, :name => "nowhere", :description => "no-horse town",
+                         :created_at => Time.now, :updated_at => Time.now)
+
+# Account sets for get_value testing
+LOW_ID_SET = 4
+DB[:account_sets].insert(:id => LOW_ID_SET, :name => "low-id", :description => "acct set, low id #",
+                         :created_at => Time.now, :updated_at => Time.now)
+BIG_VALUE_SET = 5
+DB[:account_sets].insert(:id => BIG_VALUE_SET, :name => "big-val",
+                         :description => "acct set, big value",
+                         :created_at => Time.now, :updated_at => Time.now)
+LITTLE_VALUE_SET = 6
+DB[:account_sets].insert(:id => LITTLE_VALUE_SET, :name => "little-val",
+                         :description => "acct set, little value",
+                         :created_at => Time.now, :updated_at => Time.now)
+
+VALUE_FOR_ACCT_SET = {
+  ONE_HORSE_TOWN => 1,
+  TWO_HORSE_TOWN => 2,
+  BIG_VALUE_SET => 100,
+  LITTLE_VALUE_SET => 7,
+  LOW_ID_SET => 21,
+}
+
+# Features in 0, 1 and 2 account sets, with no override, true override and false override
+[false, true].each do |fully_active|
+  [nil, true, false].each do |override|
+    [[],
+     [ONE_HORSE_TOWN],
+     [ONE_HORSE_TOWN, TWO_HORSE_TOWN],
+    ].each do |acct_sets|
+      offset = override.nil? ? 0 : (override == true ? 1 : 2)
+      offset += 3 if fully_active
+      num_accts = acct_sets.size
+      id = 1000 + offset * 100 + num_accts
+      desc = "#{fully_active ? "Fully Active " : ""}Feature w/ #{num_accts} acct sets and override #{override.inspect}"
+      account = "account_for_acct_sets_#{num_accts}_#{override.inspect}"
+      feature = "#{fully_active ? "fully_active_" : ""}feature_for_acct_sets_#{num_accts}_#{override.inspect}"
+
+      DB[:features].insert(:id => id, :name => feature, :description => desc,
+                           :created_at => Time.now, :updated_at => Time.now, :fully_active => fully_active)
+
+      acct_sets.each do |acct_set|
+        DB[:account_set_accounts].insert(:id => unique_id, :account_set_id => acct_set, :account => account,
+                                         :added_at => Time.now) unless fully_active # Only need to do this once
+        DB[:account_set_features].insert(:id => unique_id, :account_set_id => acct_set, :feature_id => id,
+                                         :value => fully_active ? 0 : 1, :added_at => Time.now) # Opposite of default
+      end
+
+      case override
+      when true
+        DB[:feature_account_overrides].insert(:account => account, :feature_id => id, :value => 1)
+      when false
+        DB[:feature_account_overrides].insert(:account => account, :feature_id => id, :value => 0)
+      when nil
+        # No-op
+      else
+        raise "Illegal value for override!"
+      end
+    end
+  end
+end
+
+[nil, 0, 1, 2, 5].each do |override|
+  counter = 0
+  [[],
+   [LITTLE_VALUE_SET],
+   [BIG_VALUE_SET, LITTLE_VALUE_SET],
+   [BIG_VALUE_SET, LITTLE_VALUE_SET, LOW_ID_SET]].each do |acct_sets|
+    acct_key = acct_sets.map(&:to_s).join("/")
+    id = 2000 + (override.nil? ? 0 : override + 1) * 100 + counter
+    counter += 1
+    desc = "Feature w/ value and  w/ acct sets #{acct_key} and override #{override.inspect}"
+    account = "account_for_value_acct_sets_#{acct_key}_#{override.inspect}"
+    feature = "feature_for_value_acct_sets_#{acct_key}_#{override.inspect}"
+
+    DB[:features].insert(:id => id, :name => feature, :description => desc,
+                         :created_at => Time.now, :updated_at => Time.now)
+
+    acct_sets.each do |acct_set|
+      DB[:account_set_accounts].insert(:id => unique_id, :account_set_id => acct_set, :account => account,
+                                       :added_at => Time.now)
+      DB[:account_set_features].insert(:id => unique_id, :account_set_id => acct_set, :feature_id => id,
+                                       :value => VALUE_FOR_ACCT_SET[acct_set], :added_at => Time.now)
+    end
+
+    if override != nil
+      DB[:feature_account_overrides].insert(:account => account, :feature_id => id,
+                                            :value => override)
+    end
+  end
+end
+
+$stderr.puts "Features: #{DB[:features].count}"
+$stderr.puts "Account Sets: #{DB[:account_sets].count}"
+$stderr.puts "Accounts/set joins: #{DB[:account_set_accounts].count}"
+$stderr.puts "Set/feature joins: #{DB[:account_set_features].count}"
+$stderr.puts "Overrides: #{DB[:feature_account_overrides].count}"
+
+$stderr.puts "Added test data successfully!"

data/test/integration/em_server_test.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__), "integration_test_helper")
+require "net/http"
+require 'multi_json'
+require "trollop"
+require "psych"
+
+EM_SERVER_TESTER_BIN = "#{GLOWWORM_ROOT}/bin/em_server_tester"
+EM_SERVER_CONFIG = "#{GLOWWORM_ROOT}/bin/em_server/config.ru"
+EM_PORT = Nodule::Util.random_tcp_port
+EM_HOST = "http://localhost:#{EM_PORT}"
+
+class EMServerTest < Scope::TestCase
+  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
+    setup_once do
+      tester_tapy = results_path('em_server_test.yaml')
+
+      # The tester command outputs results via TAP-Y and diagnostics to STDERR
+      tester_cmd = cmd_in_client_ruby_dist(EM_SERVER_TESTER_BIN, "--server #{EM_HOST} | tee #{tester_tapy}")
+      # The tester may be run under ruby 1.8. Fake like 1.9 by using RUBYOPT to include rubygems
+      # support
+      em_server = {
+        :em_server    => Nodule::Process.new({
+          "ECOLOGY_SPEC" => GLOWWORM_ECOLOGY_FILE,
+          "GW_URI"  => GW_URI,
+          "GLOWWORM_ROOT" => GLOWWORM_ROOT },
+          "bash", "-l", "-c", "cd #{GLOWWORM_ROOT} && bundle exec thin -p #{EM_PORT} -R #{EM_SERVER_CONFIG} start",
+          :stdout => :capture, :stderr => :capture, :verbose => :cyanio
+        )
+      }
+      @topology = start_tester_topology(tester_cmd, 10, em_server)
+
+      STDERR.puts "tester status #{@topology[:gw_tester].status}"
+
+      @tester_results = Psych.parse_stream(IO.read(tester_tapy)).to_ruby
+    end
+
+    teardown_once do
+      @topology.stop_all
+
+      # TODO(noah): Hideous hack until we have real RVM/Nodule integration
+      system("pkill -9 -f glowworm_server.rb")
+      system("pkill -9 -f thin")
+    end
+
+    should "test server response" do
+      contained_summary = false
+      @tester_results.each do |tap_entry|
+        if "final" == tap_entry["type"]
+          contained_summary = true
+          counts = tap_entry["counts"]
+
+          assert_equal(0, counts["fail"], "tester should have no assertion failures")
+          assert_equal(0, counts["error"], "tester should not have encountered any errors")
+          assert(counts["total"] > 0, "tester should have performed at least a single test")
+        end
+      end
+
+      assert(contained_summary, "the tester must have produced a complete output stream")
+    end
+  end
+end

data/test/integration/gemfile_for_specific_glowworm_version

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+source "http://gems.sv2"  # Ooyala-specific!
+source "http://gems.us-east-1.ooyala.com:8080"
+
+fail "requires TEST_GLOWWORM_VERSION in environment" unless ENV['TEST_GLOWWORM_VERSION']
+
+gem "glowworm", ENV['TEST_GLOWWORM_VERSION']
+
+# plus development dependencies
+gem "ansi"
+gem "minitap", ">=0.3.5"
+gem "minitest"
+gem "mocha"
+gem "rake"
+gem "scope"
+gem "tapout"
+gem "httparty"