xing-backend 0.0.19 → 0.0.20

data/lib/xing/static/logger.rb

@@ -0,0 +1,11 @@
+module Xing
+  module Static
+    require 'logger'
+    class Logger < ::Logger
+      # needed to use stdlib logger with Rack < 1.6.0
+      def write(msg)
+        self.<<(msg)
+      end
+    end
+  end
+end

data/lib/xing/static/rack_app.rb

@@ -0,0 +1,40 @@
+require 'xing/static/backend_url_cookie'
+require 'xing/static/goto_param'
+require 'xing/static/logger'
+
+module Xing
+  module Static
+    class RackApp
+      # Should be override by client app. Ironically, override with exactly
+      # this definition will usually work.
+      def self.log_root
+        File.expand_path("../../log", __FILE__)
+      end
+
+      def self.logpath_for_env(env)
+        File.join( log_root, "#{env}_static.log")
+      end
+
+      def self.build(root_path, backend_port)
+        backend_url = "http://localhost:#{backend_port}/"
+        env = ENV['RAILS_ENV'] || 'development'
+        logger = Logger.new(logpath_for_env(env))
+
+        Rack::Builder.new do
+          use BackendUrlCookie, backend_url
+          use GotoParam
+          use Rack::CommonLogger, logger
+          use Rack::Static, {
+            :urls => [""],
+            :root => root_path,
+            :index => "index.html",
+            :header_rules => {
+              :all => {"Cache-Control" => "no-cache, max-age=0" } #no caching development assets
+            }
+          }
+          run proc{}
+        end
+      end
+    end
+  end
+end

data/lib/xing/tasks/all.rake

@@ -0,0 +1,4 @@
+load 'xing/tasks/db_recycle.rake'
+load 'xing/tasks/dependencies_common.rake'
+load 'xing/tasks/sample_data.rake'
+load 'xing/tasks/take_snapshot.rake'

data/lib/xing/tasks/db_recycle.rake

@@ -0,0 +1,4 @@
+namespace :db do
+  desc "Destroy and reload the whole DB"
+  task :recycle => [ :drop, :create, :migrate, :seed ]
+end

data/lib/xing/tasks/dependencies_common.rake

@@ -0,0 +1,49 @@
+require 'xing/nominal/secrets_validator'
+require 'xing/nominal/database_config_validator'
+
+namespace :dependencies do
+  include Xing::Nominal::DependencyUtils
+
+  task :check => [
+    :secrets,
+    :database_config,
+    'redis:running'
+  ]
+  namespace :check do
+    task :tmux => 'dependencies:check' do
+      sh_or_fail "which tmux", "tmux is not installed."
+      sh_or_fail "which realpath", "realpath is not installed.  Mac users see: http://j.mp/mac_realpath"
+    end
+  end
+
+  task :secrets do
+    env = ENV['RAILS_ENV'] || 'development'
+    validator = Xing::Nominal::SecretsValidator.new
+    validator.assert_existence
+    validator.validate(env)
+    validator.report!
+  end
+
+  task :database_config do
+    env = ENV['RAILS_ENV'] || 'development'
+    validator = Xing::Nominal::DatabaseConfigValidator.new
+    validator.assert_existence
+    validator.validate(env)
+    validator.report!
+  end
+
+  task :api_host do
+    # TODO - if in development, check that the API host resolves
+  end
+
+  namespace :redis do
+    task :running => :installed do
+      sh_or_fail "redis-cli ping", "Redis is not running."
+    end
+    task :installed do
+      sh_or_fail "which redis-cli", "Redis is not installed."
+    end
+  end
+
+
+end

data/lib/xing/tasks/sample_data.rake

@@ -0,0 +1,49 @@
+# NOTE:   This task exists to create fake data for the purposes of
+# demonstrating the site to a client during development.   So whatever
+# scaffolds we create should get a method in here to generate some
+# fake entries.   Most of it should be lipsum.
+
+# IT SHOULD NOT CONTAIN any data absolutely required for the site to work,
+#   especially that we might need in testing.  For example, groups for 'users'
+#   and 'admins' if we are using an authorization system.   Such things should
+#   go in seeds.rb.
+#
+# Once the client has real data ... i.e. an initial set of pages and/or
+# a menu/location tree, those should replace the lorem data.
+
+class Array
+  # If +number+ is greater than the size of the array, the method
+  # will simply return the array itself sorted randomly
+  # defaults to picking one item
+  def pick(number = 1)
+    if (number == 1)
+      sort_by{ rand }[0]
+    else
+      sort_by{ rand }.slice(0...number)
+    end
+  end
+end
+
+# Do something sometimes (with probability p).
+def sometimes(p, &block)
+  yield(block) if rand <= p
+end
+
+namespace :db do
+  namespace :sample_data do
+
+    desc "Wipe the database and reload"
+    task :reload => [ :wipe, 'db:seed', :load]
+
+    desc "Destroy the database and reload sample data"
+    task :recycle => [ 'db:recycle', :load ]
+
+    task :wipe => [ :environment ] do
+    end
+
+    desc "Fill the database with sample data for demo purposes"
+    task :load => [ :environment, :seed ]
+  end
+end
+
+Dir[Rails.root.join("db/sample_data/**/*.{rb,rake}")].each {|f| load f}

data/lib/xing/tasks/take_snapshot.rake

@@ -0,0 +1,4 @@
+task :take_snapshot => :environment do
+  # is there anything else to this? I don't think so -- just set this up in a cron job
+  RemoteSiteSnapshot.create!(Rails.application.secrets.sitemap_base_url)
+end

data/spec/xing/builders/list_builder_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Xing::Builders::ListBuilder do
 
   let :builder do

data/spec/xing/builders/ordered_list_builder_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Xing::Builders::OrderedListBuilder do
 
   let :builder do

data/spec/xing/nominal/database_config_validator_spec.rb

@@ -0,0 +1,98 @@
+require 'xing/nominal/database_config_validator'
+
+describe Xing::Nominal::DatabaseConfigValidator do
+
+  before do
+    expect(File).to receive(:open).and_return(nil)
+  end
+
+  let :dev_yaml do
+    YAML.load(DEV_FIXTURE)
+  end
+
+  let :prod_yaml do
+    YAML.load(PROD_FIXTURE)
+  end
+
+  it "when development has a missing key" do
+    expect(YAML).to receive(:load).and_return(dev_yaml.deep_merge({'development' => { 'database' => nil }}))
+    validator = Xing::Nominal::DatabaseConfigValidator.new
+    validator.validate('development')
+    expect(validator.errors['development']).not_to be_blank
+    expect(validator.errors['test']).to            be_blank
+  end
+
+  it "succeeds when development has no missing keys" do
+    expect(YAML).to receive(:load).and_return(dev_yaml)
+    validator = Xing::Nominal::DatabaseConfigValidator.new
+    validator.validate('development')
+    expect(validator.errors['development']).to be_blank
+    expect(validator.errors['test']).to        be_blank
+  end
+
+  it "when development has a missing key and test has a misformatted value " do
+    expect(YAML).to receive(:load).and_return(dev_yaml.deep_merge({
+      'development' => { 'adapter'  => nil  },
+      'test'        => { 'database' => 1000 }})
+    )
+    validator = Xing::Nominal::DatabaseConfigValidator.new
+    validator.validate('development')
+    expect(validator.errors['development']['adapter']).not_to be_blank
+    expect(validator.errors['test']['database']).not_to       be_blank
+  end
+
+  context "production" do
+    it "succeeds when all values are present" do
+      expect(YAML).to receive(:load).and_return(prod_yaml)
+      validator = Xing::Nominal::DatabaseConfigValidator.new
+      validator.validate('production')
+      expect(validator.errors).to be_blank
+    end
+
+    it "requires username" do
+      expect(YAML).to receive(:load).and_return(prod_yaml.deep_merge({'production' => { 'username' => nil }}))
+      validator = Xing::Nominal::DatabaseConfigValidator.new
+      validator.validate('production')
+      expect(validator.errors['production']['username']).not_to be_blank
+    end
+
+    it "requires password" do
+      expect(YAML).to receive(:load).and_return(prod_yaml.deep_merge({'production' => { 'password' => nil }}))
+      validator = Xing::Nominal::DatabaseConfigValidator.new
+      validator.validate('production')
+      expect(validator.errors['production']['password']).not_to be_blank
+    end
+
+    it "requires host" do
+      expect(YAML).to receive(:load).and_return(prod_yaml.deep_merge({'production' => { 'host' => nil }}))
+      validator = Xing::Nominal::DatabaseConfigValidator.new
+      validator.validate('production')
+      expect(validator.errors['production']['host']).not_to be_blank
+    end
+  end
+
+
+  DEV_FIXTURE = <<EOS
+development:
+  adapter: postgresql
+  encoding: unicode
+  database: cms2_dev
+
+test:
+  adapter: postgresql
+  encoding: unicode
+  database: cms2_dev
+EOS
+
+  PROD_FIXTURE = <<EOS
+
+production:
+  adapter: postgresql
+  encoding: unicode
+  database: cms2_dev
+  username: a_user
+  password: abcdef
+  host: 127.0.0.1
+EOS
+
+end

data/spec/xing/nominal/secrets_validator_spec.rb

@@ -0,0 +1,78 @@
+require 'xing/nominal/secrets_validator'
+
+describe Xing::Nominal::SecretsValidator do
+  before do
+    expect(File).to receive(:open).and_return(nil)
+  end
+
+  let :dev_yaml do
+    YAML.load(FIXTURE)
+  end
+
+  it "when development has a missing key" do
+    expect(YAML).to receive(:load).and_return(dev_yaml.deep_merge({'development' => { 'email' => nil }}))
+    validator = Xing::Nominal::SecretsValidator.new
+    validator.validate('development')
+    expect(validator.errors['development']).not_to be_blank
+    expect(validator.errors['test']).to be_blank
+  end
+
+  it "when development has no missing keys" do
+    expect(YAML).to receive(:load).and_return(dev_yaml)
+    validator = Xing::Nominal::SecretsValidator.new
+    validator.validate('development')
+    expect(validator.errors).to be_blank
+  end
+
+  it "when development has a missing key and test has a misformatted value " do
+    expect(YAML).to receive(:load).and_return(dev_yaml.deep_merge({
+      'development' => { 'email' => nil },
+      'test'        => { 'email' => { 'from' => 'not_an_email' } }})
+    )
+    validator = Xing::Nominal::SecretsValidator.new
+    validator.validate('development')
+    expect(validator.errors['development']['email']) .not_to be_blank
+    expect(validator.errors['test']['email']['from']).not_to be_blank
+  end
+
+  FIXTURE = <<EOS
+development:
+  secret_key_base: xxxkey
+  smtp:
+    address: smtp.gmail.com
+    port: 587
+    domain: lrdesign.com
+    user_name: quentin@lrdesign.com
+    password: xxxxxxxx
+  email:
+    from: quentin@lrdesign.com
+    reply_to: quentin@lrdesign.com
+    from_domain: lrdesign.com
+    test: test@lrdesign.com
+  snapshot_server:
+    url: https://www.notaserver.com
+    user: user
+    password: password
+  sitemap_base_url: http://localhost:3000/
+
+test:
+  secret_key_base: xxkey
+  smtp:
+    address: smtp.gmail.com
+    port: 587
+    domain: equibid.com
+    user_name: sysquentin@equibid.com
+    password: xxxxxxxx
+  email:
+    from: quentin@example.com
+    reply_to: quentin@example.com
+    from_domain: lrdesign.com
+    test: test@lrdesign.com
+  snapshot_server:
+    url: https://www.notaserver.com
+    user: user
+    password: password
+  sitemap_base_url: http://localhost:3000/
+EOS
+
+end

data/spec/xing/serializers/list_spec.rb

@@ -0,0 +1,116 @@
+require 'xing/serializers/list'
+require 'json_spec'
+
+describe Xing::Serializers::List do
+  include JsonSpec::Matchers
+
+  class ItemSerializer < Xing::Serializers::Base
+    attributes :name, :position
+    def links
+      { :self => 'url_for_this_model' }
+    end
+  end
+
+  let :list do
+    (1..3).map do |index|
+      double("a mock activemodel").tap do |model|
+        allow(model).to receive(:read_attribute_for_serialization).with(:name).and_return("Name #{index}!")
+        allow(model).to receive(:read_attribute_for_serialization).with(:position).and_return(index)
+      end
+    end
+  end
+
+  let :total_pages do 3 end
+
+  let :serializer do
+    ListSerializer.new(list)
+  end
+
+  let :json do
+    serializer.to_json
+  end
+
+  describe 'with template link' do
+    class ListSerializer < Xing::Serializers::List
+      def item_serializer_class
+        ItemSerializer
+      end
+
+      def template_link
+        "template_url_for_list"
+      end
+
+      def self_link
+        "url_for_list"
+      end
+    end
+
+    it "should have the correct structure" do
+      expect(json).to have_json_path('links/self')
+      expect(json).to have_json_path('links/template')
+      expect(json).to have_json_path('data/')
+    end
+
+    it "should generate a JSON with the proper links and self" do
+      expect(json).to be_json_eql('"url_for_list"').at_path('links/self')
+      expect(json).to be_json_eql('"template_url_for_list"').at_path('links/template')
+      expect(json).to be_json_eql('"Name 2!"').at_path('data/1/data/name')
+      expect(json).to be_json_eql('2').at_path('data/1/data/position')
+      expect(json).to be_json_eql('"url_for_this_model"').at_path('data/1/links/self')
+    end
+
+    it "should call the video response serializer" do
+      expect(ItemSerializer).to receive(:new).with(list[0], anything)
+      expect(ItemSerializer).to receive(:new).with(list[1], anything)
+      expect(ItemSerializer).to receive(:new).with(list[2], anything)
+      expect(json).to have_json_size(3).at_path('data')
+    end
+  end
+
+  describe 'without template link' do
+    class ListSerializerWithoutTemplateLink < Xing::Serializers::List
+      def item_serializer_class
+        ItemSerializer
+      end
+
+      def self_link
+        "url_for_list"
+      end
+    end
+
+    let :serializer do
+      ListSerializerWithoutTemplateLink.new(list)
+    end
+
+    it "should have the correct structure" do
+      expect(json).to have_json_path('links/self')
+      expect(json).to_not have_json_path('links/template')
+      expect(json).to have_json_path('data/')
+    end
+
+    it "should generate a JSON with the proper links and self" do
+      expect(json).to be_json_eql('"url_for_list"').at_path('links/self')
+      expect(json).to be_json_eql('"Name 2!"').at_path('data/1/data/name')
+      expect(json).to be_json_eql('2').at_path('data/1/data/position')
+      expect(json).to be_json_eql('"url_for_this_model"').at_path('data/1/links/self')
+    end
+  end
+
+  describe 'a badly formed subclass' do
+    class BrokenListSerializer < Xing::Serializers::List
+      def item_serializer_class
+        ItemSerializer
+      end
+    end
+
+    let :serializer do
+      BrokenListSerializer.new(list)
+    end
+
+    it "should fail" do
+      expect do
+        json
+      end.to raise_error(NotImplementedError)
+    end
+  end
+end