levels 0.1.0

data/test/acceptance/read_system_test.rb

@@ -0,0 +1,121 @@
+require 'helper'
+
+describe "acceptance: read system" do
+
+  def read_system(level_name, template, prefix, env)
+    key_formatter = Levels::System::KeyFormatter.new(prefix)
+    level = Levels::Level.new(level_name)
+    input = Levels::Input::System.new(template, key_formatter, env)
+    input.read(level)
+    level
+  end
+
+  describe "using typecast information" do
+
+    let(:template) {
+      level = Levels::Level.new("template level")
+      level.set_group(:types,
+        string: nil,
+        integer: nil,
+        float: nil,
+        boolean_true: nil,
+        boolean_false: nil,
+        array_of_string: nil,
+        array_of_integer: nil,
+        null: nil
+      )
+      level.set_group(:group2,
+        message: nil
+      )
+      level
+    }
+
+    let(:env) {
+      {
+        "TYPES_STRING" => "hello",
+        "TYPES_INTEGER" => "123",
+        "TYPES_INTEGER_TYPE" => "integer",
+        "TYPES_FLOAT" => "1.5",
+        "TYPES_FLOAT_TYPE" => "float",
+        "TYPES_BOOLEAN_TRUE" => "true",
+        "TYPES_BOOLEAN_TRUE_TYPE" => "boolean",
+        "TYPES_BOOLEAN_FALSE" => "false",
+        "TYPES_BOOLEAN_FALSE_TYPE" => "boolean",
+        "TYPES_ARRAY_OF_STRING" => "a:b:c",
+        "TYPES_ARRAY_OF_STRING_TYPE" => "array",
+        "TYPES_ARRAY_OF_INTEGER" => "1:2:3",
+        "TYPES_ARRAY_OF_INTEGER_TYPE" => "array",
+        "TYPES_ARRAY_OF_INTEGER_TYPE_TYPE" => "integer",
+        "TYPES_NULL" => "",
+        "GROUP2_MESSAGE" => "hello world"
+      }
+    }
+
+    subject { read_system("the system", template.to_enum, nil, env) }
+
+    assert_sample_data_set
+  end
+
+  describe "using the template's types" do
+
+    let(:template) {
+      level = Levels::Level.new("template level")
+      level.set_group(:types,
+        string: "!hello",
+        integer: 0123,
+        float: 1.55,
+        boolean_true: false,
+        boolean_false: true,
+        array_of_string: ["a", "a", "a"],
+        array_of_integer: [1, 1, 1],
+        null: 999
+      )
+      level.set_group(:group2,
+        message: "hello there"
+      )
+      level
+    }
+
+    let(:env) {
+      {
+        "TYPES_STRING" => "hello",
+        "TYPES_INTEGER" => "123",
+        "TYPES_FLOAT" => "1.5",
+        "TYPES_BOOLEAN_TRUE" => "true",
+        "TYPES_BOOLEAN_FALSE" => "false",
+        "TYPES_ARRAY_OF_STRING" => "a:b:c",
+        "TYPES_ARRAY_OF_INTEGER" => "1:2:3",
+        "TYPES_NULL" => "",
+        "GROUP2_MESSAGE" => "hello world"
+      }
+    }
+
+    subject { read_system("the system", template.to_enum, nil, env) }
+
+    assert_sample_data_set
+  end
+
+  describe "using a prefix" do
+
+    let(:template) {
+      level = Levels::Level.new("template level")
+      level.set_group(:group,
+        message: "hello there"
+      )
+      level
+    }
+
+    let(:env) {
+      {
+        "PREFIX_GROUP_MESSAGE" => "hello world"
+      }
+    }
+
+    subject { read_system("the system", template.to_enum, "PREFIX_", env) }
+
+    it "finds values" do
+      subject.group.message.must_equal "hello world"
+    end
+  end
+end
+

data/test/acceptance/read_yaml_test.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+describe "acceptance: read yaml" do
+
+  def read_yaml(level_name, yaml_string)
+    level = Levels::Level.new(level_name)
+    input = Levels::Input::YAML.new(yaml_string)
+    input.read(level)
+    level
+  end
+
+  let(:yaml) {
+    <<-YAML
+types:
+  string: hello
+  integer: 123
+  float: 1.5
+  boolean_true: true
+  boolean_false: false
+  array_of_string:
+    - a
+    - b
+    - c
+  array_of_integer:
+    - 1
+    - 2
+    - 3
+  "null": null
+group2:
+  message: hello world
+    YAML
+  }
+
+  subject { read_yaml("test", yaml) }
+
+  assert_sample_data_set
+end
+

data/test/acceptance/setup_test.rb

@@ -0,0 +1,115 @@
+require 'helper'
+
+describe "acceptance: the Setup" do
+
+  subject { Levels::Setup.new }
+
+  describe "reading various inputs" do
+
+    let(:ruby_code) do
+      <<-RUBY
+group :group
+  set a: 1
+      RUBY
+    end
+
+    let(:json_code) do
+      <<-JSON
+{
+  "group": {
+    "a": 1
+  }
+}
+      JSON
+    end
+
+    let(:yaml_code) do
+      <<-YAML
+---
+group:
+  a: 1
+      YAML
+    end
+
+    it "adds a custom source" do
+      custom_input = Class.new do
+        def read(level)
+          level.set_group(:group, a: 1)
+        end
+      end
+      custom = custom_input.new
+
+      subject.add("custom", custom)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds ruby code" do
+      subject.add("code", ruby_code)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds JSON code" do
+      subject.add("code", json_code)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds YAML code" do
+      subject.add("code", yaml_code)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds a ruby file" do
+      file = w("input.rb", ruby_code)
+      subject.add("file", file.to_s)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds a JSON file" do
+      file = w("input.json", json_code)
+      subject.add("file", file.to_s)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds a YAML file (.yml)" do
+      file = w("input.yml", yaml_code)
+      subject.add("file", file.to_s)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds a YAML file (.yaml)" do
+      file = w("input.yaml", yaml_code)
+      subject.add("file", file.to_s)
+      subject.merge.group.a.must_equal 1
+    end
+
+    it "adds system variables" do
+      begin
+        subject.add "code", '{ "group": { "a": 0 } }'
+        subject.add_system
+        ENV['GROUP_A'] = '1'
+        subject.merge.group.a.must_equal 1
+      ensure
+        ENV.delete('GROUP_A')
+      end
+    end
+
+    it "adds system variables with a prefix" do
+      begin
+        subject.add "code", '{ "group": { "a": 0 } }'
+        subject.add_system 'PFX_'
+        ENV['PFX_GROUP_A'] = '1'
+        subject.merge.group.a.must_equal 1
+      ensure
+        ENV.delete('PFX_GROUP_A')
+      end
+    end
+
+    it "adds a Level" do
+      level = Levels::Level.new("test")
+      level.set_group(:group, a: 1)
+
+      subject.add_level(level)
+      subject.merge.group.a.must_equal 1
+    end
+  end
+end

data/test/acceptance/write_json_test.rb

@@ -0,0 +1,39 @@
+require 'helper'
+
+describe "acceptance: write json" do
+
+  def write_json(level)
+    output = Levels::Output::JSON.new
+    output.generate(level.to_enum)
+  end
+
+  it "converts to JSON" do
+    output = write_json(standard_data_types_level)
+    output.must_equal <<-JSON.chomp
+{
+  "types": {
+    "string": "hello",
+    "integer": 123,
+    "float": 1.5,
+    "boolean_true": true,
+    "boolean_false": false,
+    "array_of_string": [
+      "a",
+      "b",
+      "c"
+    ],
+    "array_of_integer": [
+      1,
+      2,
+      3
+    ],
+    "null": null
+  },
+  "group2": {
+    "message": "hello world"
+  }
+}
+    JSON
+  end
+end
+

data/test/acceptance/write_system_test.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+describe "acceptance: write system" do
+
+  def write_system(level, prefix = nil)
+    key_formatter = Levels::System::KeyFormatter.new(prefix)
+    output = Levels::Output::System.new(key_formatter)
+    output.generate(level.to_enum)
+  end
+
+  it "converts to ENV variables" do
+    output = write_system(standard_data_types_level)
+    output.must_equal <<-ENV.chomp
+export TYPES_STRING="hello"
+export TYPES_STRING_TYPE="string"
+export TYPES_INTEGER="123"
+export TYPES_INTEGER_TYPE="integer"
+export TYPES_FLOAT="1.5"
+export TYPES_FLOAT_TYPE="float"
+export TYPES_BOOLEAN_TRUE="true"
+export TYPES_BOOLEAN_TRUE_TYPE="boolean"
+export TYPES_BOOLEAN_FALSE="false"
+export TYPES_BOOLEAN_FALSE_TYPE="boolean"
+export TYPES_ARRAY_OF_STRING="a:b:c"
+export TYPES_ARRAY_OF_STRING_TYPE="array"
+export TYPES_ARRAY_OF_STRING_DELIMITER=":"
+export TYPES_ARRAY_OF_STRING_TYPE_TYPE="string"
+export TYPES_ARRAY_OF_INTEGER="1:2:3"
+export TYPES_ARRAY_OF_INTEGER_TYPE="array"
+export TYPES_ARRAY_OF_INTEGER_DELIMITER=":"
+export TYPES_ARRAY_OF_INTEGER_TYPE_TYPE="integer"
+export TYPES_NULL=""
+export TYPES_NULL_TYPE="string"
+export GROUP2_MESSAGE="hello world"
+export GROUP2_MESSAGE_TYPE="string"
+    ENV
+  end
+
+  it "converts to ENV variables with a prefix" do
+    output = write_system(standard_data_types_level, "FOO_")
+    output.must_equal <<-ENV.chomp
+export FOO_TYPES_STRING="hello"
+export FOO_TYPES_STRING_TYPE="string"
+export FOO_TYPES_INTEGER="123"
+export FOO_TYPES_INTEGER_TYPE="integer"
+export FOO_TYPES_FLOAT="1.5"
+export FOO_TYPES_FLOAT_TYPE="float"
+export FOO_TYPES_BOOLEAN_TRUE="true"
+export FOO_TYPES_BOOLEAN_TRUE_TYPE="boolean"
+export FOO_TYPES_BOOLEAN_FALSE="false"
+export FOO_TYPES_BOOLEAN_FALSE_TYPE="boolean"
+export FOO_TYPES_ARRAY_OF_STRING="a:b:c"
+export FOO_TYPES_ARRAY_OF_STRING_TYPE="array"
+export FOO_TYPES_ARRAY_OF_STRING_DELIMITER=":"
+export FOO_TYPES_ARRAY_OF_STRING_TYPE_TYPE="string"
+export FOO_TYPES_ARRAY_OF_INTEGER="1:2:3"
+export FOO_TYPES_ARRAY_OF_INTEGER_TYPE="array"
+export FOO_TYPES_ARRAY_OF_INTEGER_DELIMITER=":"
+export FOO_TYPES_ARRAY_OF_INTEGER_TYPE_TYPE="integer"
+export FOO_TYPES_NULL=""
+export FOO_TYPES_NULL_TYPE="string"
+export FOO_GROUP2_MESSAGE="hello world"
+export FOO_GROUP2_MESSAGE_TYPE="string"
+    ENV
+  end
+end
+
+

data/test/acceptance/write_yaml_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+describe "acceptance: write yaml" do
+
+  def write_yaml(level)
+    output = Levels::Output::YAML.new
+    output.generate(level.to_enum)
+  end
+
+  it "converts to YAML" do
+    output = write_yaml(standard_data_types_level)
+    output.must_equal <<-JSON.sub(/'null':$/, '\0 ') # Handle trailing space for null.
+---
+types:
+  string: hello
+  integer: 123
+  float: 1.5
+  boolean_true: true
+  boolean_false: false
+  array_of_string:
+  - a
+  - b
+  - c
+  array_of_integer:
+  - 1
+  - 2
+  - 3
+  'null':
+group2:
+  message: hello world
+    JSON
+  end
+end

data/test/bin/merge_test.rb

@@ -0,0 +1,194 @@
+require 'helper'
+
+describe "bin: merge" do
+
+  let(:ruby_syntax) do
+    <<-STR
+group :sample
+  set message: "hello"
+    STR
+  end
+
+  let(:json_syntax) do
+    <<-STR
+{
+  "sample": {
+    "message": "hello"
+  }
+}
+    STR
+  end
+
+  let(:yaml_syntax) do
+    <<-STR
+---
+sample:
+  message: hello
+    STR
+  end
+
+  let(:system_syntax) do
+    <<-STR
+export SAMPLE_MESSAGE="hello"
+export SAMPLE_MESSAGE_TYPE="string"
+    STR
+  end
+
+  let(:system_syntax_with_prefix) do
+    <<-STR
+export FOO_SAMPLE_MESSAGE="hello"
+export FOO_SAMPLE_MESSAGE_TYPE="string"
+    STR
+  end
+
+  let(:merged_json_syntax) do
+    <<-STR
+{
+  "sample": {
+    "message": "goodbye"
+  }
+}
+    STR
+  end
+
+  let(:merged_system_keys) do
+    {
+      "SAMPLE_MESSAGE" => "goodbye",
+      "SAMPLE_MESSAGE_TYPE" => "string"
+    }
+  end
+
+  let(:merged_system_keys_with_prefix) do
+    {
+      "FOO_SAMPLE_MESSAGE" => "goodbye",
+      "FOO_SAMPLE_MESSAGE_TYPE" => "string"
+    }
+  end
+
+  describe "reading files" do
+
+    it "reads a ruby file" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels #{f 'one.rb'}"
+      stdout.must_equal json_syntax
+    end
+
+    it "reads a json file" do
+      w("one.json", json_syntax)
+      assert_success "levels #{f 'one.json'}"
+      stdout.must_equal json_syntax
+    end
+
+    it "reads a yaml file" do
+      w("one.yaml", yaml_syntax)
+      assert_success "levels #{f 'one.yaml'}"
+      stdout.must_equal json_syntax
+    end
+
+    it "reads a yml file" do
+      w("one.yml", yaml_syntax)
+      assert_success "levels #{f 'one.yml'}"
+      stdout.must_equal json_syntax
+    end
+
+    it "merges files" do
+      w("one.rb", ruby_syntax)
+      w("one.json", merged_json_syntax)
+      assert_success "levels #{f 'one.rb'} #{f 'one.json'}"
+      stdout.must_equal merged_json_syntax
+    end
+  end
+
+  describe "reading the system" do
+
+    it "merges with the base" do
+      w("one.rb", ruby_syntax)
+      set_env merged_system_keys
+      assert_success "levels --system #{f 'one.rb'}"
+      stdout.must_equal merged_json_syntax
+    end
+
+    it "merges with the base with a prefix" do
+      w("one.rb", ruby_syntax)
+      set_env merged_system_keys_with_prefix
+      assert_success "levels --system FOO_ #{f 'one.rb'}"
+      stdout.must_equal merged_json_syntax
+    end
+  end
+
+  describe "writing output" do
+
+    it "writes json" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --output json #{f 'one.rb'}"
+      stdout.must_equal json_syntax
+    end
+
+    it "writes yaml" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --output yaml #{f 'one.rb'}"
+      stdout.must_equal yaml_syntax
+    end
+
+    it "writes system" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --output system #{f 'one.rb'}"
+      stdout.must_equal system_syntax
+    end
+
+    it "writes system with a prefix" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --output system --prefix FOO_ #{f 'one.rb'}"
+      stdout.must_equal system_syntax_with_prefix
+    end
+  end
+
+  describe "logging" do
+
+    it "logs each file read" do
+      w("one.rb", ruby_syntax)
+      w("one.json", json_syntax)
+      assert_success "levels --no-output #{f 'one.rb'} #{f 'one.json'}"
+      stderr.must_equal <<-STR
+Add level "one.rb" from one.rb
+Add level "one.json" from one.json
+      STR
+      stdout.must_equal ""
+    end
+
+    it "logs when the files are given level names" do
+      w("one.rb", ruby_syntax)
+      w("two.rb", ruby_syntax)
+      w("one.json", json_syntax)
+      w("three.rb", ruby_syntax)
+      assert_success "levels --no-output --level 'RB one' --level --level 'JSON one' #{f 'one.rb'} #{f 'two.rb'} #{f 'one.json'} #{f 'three.rb'}"
+      stderr.must_equal <<-STR
+Add level "RB one" from one.rb
+Add level "two.rb" from two.rb
+Add level "JSON one" from one.json
+Add level "three.rb" from three.rb
+      STR
+      stdout.must_equal ""
+    end
+
+    it "logs when the system is used" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --no-output --system --level 'First Level' #{f 'one.rb'}"
+      stderr.must_equal <<-STR
+Add level "First Level" from one.rb
+Add level "System Environment"
+      STR
+      stdout.must_equal ""
+    end
+
+    it "logs when the system is used with a prefix" do
+      w("one.rb", ruby_syntax)
+      assert_success "levels --no-output --system FOO_ --level 'First Level' #{f 'one.rb'}"
+      stderr.must_equal <<-STR
+Add level "First Level" from one.rb
+Add level "System Environment" with prefix FOO_
+      STR
+      stdout.must_equal ""
+    end
+  end
+end