hotdog 0.1.18 → 0.2.0

data/spec/formatter/plain_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/plain"
+
+describe "plain" do
+  let(:fmt) {
+    Hotdog::Formatters::Plain.new
+  }
+
+  it "generates plain (print0) without headers" do
+    options = {
+      headers: false,
+      print0: true,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1\0bar bbb 2\0baz ccc 3")
+  end
+
+  it "generates plain (print0) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: true,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1\0bar bbb 2\0baz ccc 3")
+  end
+
+  it "generates plain (print1) without headers" do
+    options = {
+      headers: false,
+      print0: false,
+      print1: true,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+foo aaa 1
+bar bbb 2
+baz ccc 3
+    EOS
+  end
+
+  it "generates plain (print1) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: false,
+      print1: true,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+key1 key2 val1
+---- ---- ----
+foo  aaa  1   
+bar  bbb  2   
+baz  ccc  3   
+    EOS
+  end
+
+  it "generates plain (space) without headers" do
+    options = {
+      headers: false,
+      print0: false,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1 bar bbb 2 baz ccc 3\n")
+  end
+
+  it "generates plain (space) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: false,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1 bar bbb 2 baz ccc 3\n")
+  end
+end

data/spec/formatter/text_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/text"
+
+describe "text" do
+  let(:fmt) {
+    Hotdog::Formatters::Text.new
+  }
+
+  it "generates text (print0) without headers" do
+    options = {
+      headers: false,
+      print0: true,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1\0bar bbb 2\0baz ccc 3")
+  end
+
+  it "generates text (print0) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: true,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1\0bar bbb 2\0baz ccc 3")
+  end
+
+  it "generates text (print1) without headers" do
+    options = {
+      headers: false,
+      print0: false,
+      print1: true,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+foo aaa 1
+bar bbb 2
+baz ccc 3
+    EOS
+  end
+
+  it "generates text (print1) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: false,
+      print1: true,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+key1 key2 val1
+---- ---- ----
+foo  aaa  1   
+bar  bbb  2   
+baz  ccc  3   
+    EOS
+  end
+
+  it "generates text (space) without headers" do
+    options = {
+      headers: false,
+      print0: false,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1 bar bbb 2 baz ccc 3\n")
+  end
+
+  it "generates text (space) with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+      print0: false,
+      print1: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq("foo aaa 1 bar bbb 2 baz ccc 3\n")
+  end
+end

data/spec/formatter/tsv_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/tsv"
+
+describe "tsv" do
+  let(:fmt) {
+    Hotdog::Formatters::Tsv.new
+  }
+
+  it "generates tsv without headers" do
+    options = {
+      headers: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+foo\taaa\t1
+bar\tbbb\t2
+baz\tccc\t3
+    EOS
+  end
+
+  it "generates tsv with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+key1\tkey2\tval1
+foo\taaa\t1
+bar\tbbb\t2
+baz\tccc\t3
+    EOS
+  end
+end

data/spec/formatter/yaml_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+require "hotdog/formatters"
+require "hotdog/formatters/yaml"
+
+describe "yaml" do
+  let(:fmt) {
+    Hotdog::Formatters::Yaml.new
+  }
+
+  it "generates yaml without headers" do
+    options = {
+      headers: false,
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+---
+- - foo
+  - aaa
+  - 1
+- - bar
+  - bbb
+  - 2
+- - baz
+  - ccc
+  - 3
+    EOS
+  end
+
+  it "generates yaml with headers" do
+    options = {
+      headers: true,
+      fields: ["key1", "key2", "val1"],
+    }
+    expect(fmt.format([["foo", "aaa", 1], ["bar", "bbb", 2], ["baz", "ccc", 3]], options)).to eq(<<-EOS)
+---
+- - key1
+  - key2
+  - val1
+- - foo
+  - aaa
+  - 1
+- - bar
+  - bbb
+  - 2
+- - baz
+  - ccc
+  - 3
+    EOS
+  end
+end

data/spec/parser/parser_spec.rb

@@ -0,0 +1,300 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "parser" do
+  let(:cmd) {
+    Hotdog::Commands::Search.new(Hotdog::Application.new)
+  }
+
+  before(:each) do
+    ENV["DATADOG_API_KEY"] = "DATADOG_API_KEY"
+    ENV["DATADOG_APPLICATION_KEY"] = "DATADOG_APPLICATION_KEY"
+  end
+
+  it "parses ':foo'" do
+    expect(cmd.parse(":foo")).to eq({attribute: "foo"})
+  end
+
+  it "parses ':foo*'" do
+    expect(cmd.parse(":foo*")).to eq({attribute_glob: "foo*"})
+  end
+
+  it "parses ':/foo/'" do
+    expect(cmd.parse(":/foo/")).to eq({attribute_regexp: "/foo/"})
+  end
+
+  it "parses 'foo'" do
+    expect(cmd.parse("foo")).to eq({identifier: "foo"})
+  end
+
+  it "parses 'foo:bar'" do
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+  end
+
+  it "parses 'foo: bar'" do
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+  end
+
+  it "parses 'foo :bar'" do
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+  end
+
+  it "parses 'foo : bar'" do
+    expect(cmd.parse("foo:bar")).to eq({identifier: "foo", attribute: "bar"})
+  end
+
+  it "parses 'foo:bar*'" do
+    expect(cmd.parse("foo:bar*")).to eq({identifier: "foo", attribute_glob: "bar*"})
+  end
+
+  it "parses 'foo*'" do
+    expect(cmd.parse("foo*")).to eq({identifier_glob: "foo*"})
+  end
+
+  it "parses 'foo*:bar'" do
+    expect(cmd.parse("foo*:bar")).to eq({identifier_glob: "foo*", attribute: "bar"})
+  end
+
+  it "parses 'foo*:bar*'" do
+    expect(cmd.parse("foo*:bar*")).to eq({identifier_glob: "foo*", attribute_glob: "bar*"})
+  end
+
+  it "parses '/foo/'" do
+    expect(cmd.parse("/foo/")).to eq({identifier_regexp: "/foo/"})
+  end
+
+  it "parses '/foo/:/bar/'" do
+    expect(cmd.parse("/foo/:/bar/")).to eq({identifier_regexp: "/foo/", attribute_regexp: "/bar/"})
+  end
+
+  it "parses '(foo)'" do
+    expect(cmd.parse("(foo)")).to eq({identifier: "foo"})
+  end
+
+  it "parses '( foo )'" do
+    expect(cmd.parse("( foo )")).to eq({identifier: "foo"})
+  end
+
+  it "parses ' ( foo ) '" do
+    expect(cmd.parse(" ( foo ) ")).to eq({identifier: "foo"})
+  end
+
+  it "parses '((foo))'" do
+    expect(cmd.parse("((foo))")).to eq({identifier: "foo"})
+  end
+
+  it "parses '(( foo ))'" do
+    expect(cmd.parse("(( foo ))")).to eq({identifier: "foo"})
+  end
+
+  it "parses ' ( ( foo ) ) '" do
+    expect(cmd.parse("( ( foo ) )")).to eq({identifier: "foo"})
+  end
+
+  it "parses 'foo bar'" do
+    expect(cmd.parse("foo bar")).to eq({left: {identifier: "foo"}, binary_op: nil, right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo bar baz'" do
+    expect(cmd.parse("foo bar baz")).to eq({left: {identifier: "foo"}, binary_op: nil, right: {left: {identifier: "bar"}, binary_op: nil, right: {identifier: "baz"}}})
+  end
+
+  it "parses 'not foo'" do
+    expect(cmd.parse("not foo")).to eq({unary_op: "not", expression: {identifier: "foo"}})
+  end
+
+  it "parses '! foo'" do
+    expect(cmd.parse("! foo")).to eq({unary_op: "!", expression: {identifier: "foo"}})
+  end
+
+  it "parses '~ foo'" do
+    expect(cmd.parse("~ foo")).to eq({unary_op: "~", expression: {identifier: "foo"}})
+  end
+
+  it "parses 'not(not foo)'" do
+    expect(cmd.parse("not(not foo)")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '!(!foo)'" do
+    expect(cmd.parse("!(!foo)")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '~(~foo)'" do
+    expect(cmd.parse("~(~foo)")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+  end
+
+  it "parses 'not not foo'" do
+    expect(cmd.parse("not not foo")).to eq({unary_op: "not", expression: {unary_op: "not", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '!!foo'" do
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '! ! foo'" do
+    expect(cmd.parse("!! foo")).to eq({unary_op: "!", expression: {unary_op: "!", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '~~foo'" do
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+  end
+
+  it "parses '~ ~ foo'" do
+    expect(cmd.parse("~~ foo")).to eq({unary_op: "~", expression: {unary_op: "~", expression: {identifier: "foo"}}})
+  end
+
+  it "parses 'foo and bar'" do
+    expect(cmd.parse("foo and bar")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo and bar and baz'" do
+    expect(cmd.parse("foo and bar and baz")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {left: {identifier: "bar"}, binary_op: "and", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo&bar'" do
+    expect(cmd.parse("foo&bar")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo & bar'" do
+    expect(cmd.parse("foo & bar")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo&bar&baz'" do
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {left: {identifier: "bar"}, binary_op: "&", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo & bar & baz'" do
+    expect(cmd.parse("foo & bar & baz")).to eq({left: {identifier: "foo"}, binary_op: "&", right: {left: {identifier: "bar"}, binary_op: "&", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo&&bar'" do
+    expect(cmd.parse("foo&&bar")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo && bar'" do
+    expect(cmd.parse("foo && bar")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo&&bar&&baz'" do
+    expect(cmd.parse("foo&&bar&&baz")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {left: {identifier: "bar"}, binary_op: "&&", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo && bar && baz'" do
+    expect(cmd.parse("foo && bar && baz")).to eq({left: {identifier: "foo"}, binary_op: "&&", right: {left: {identifier: "bar"}, binary_op: "&&", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo or bar'" do
+    expect(cmd.parse("foo or bar")).to eq({left: {identifier: "foo"}, binary_op: "or", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo or bar or baz'" do
+    expect(cmd.parse("foo or bar or baz")).to eq({left: {identifier: "foo"}, binary_op: "or", right: {left: {identifier: "bar"}, binary_op: "or", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo|bar'" do
+    expect(cmd.parse("foo|bar")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo | bar'" do
+    expect(cmd.parse("foo | bar")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo|bar|baz'" do
+    expect(cmd.parse("foo|bar|baz")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {left: {identifier: "bar"}, binary_op: "|", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo | bar | baz'" do
+    expect(cmd.parse("foo | bar | baz")).to eq({left: {identifier: "foo"}, binary_op: "|", right: {left: {identifier: "bar"}, binary_op: "|", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo||bar'" do
+    expect(cmd.parse("foo||bar")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo || bar'" do
+    expect(cmd.parse("foo || bar")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {identifier: "bar"}})
+  end
+
+  it "parses 'foo||bar||baz'" do
+    expect(cmd.parse("foo||bar||baz")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {left: {identifier: "bar"}, binary_op: "||", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'foo || bar || baz'" do
+    expect(cmd.parse("foo || bar || baz")).to eq({left: {identifier: "foo"}, binary_op: "||", right: {left: {identifier: "bar"}, binary_op: "||", right: {identifier: "baz"}}})
+  end
+
+  it "parses '(foo and bar) or baz'" do
+    expect(cmd.parse("(foo and bar) or baz")).to eq({left: {left: {identifier: "foo"}, binary_op: "and", right: {identifier: "bar"}}, binary_op: "or", right: {identifier: "baz"}})
+  end
+
+  it "parses 'foo and (bar or baz)'" do
+    expect(cmd.parse("foo and (bar or baz)")).to eq({left: {identifier: "foo"}, binary_op: "and", right: {left: {identifier: "bar"}, binary_op: "or", right: {identifier: "baz"}}})
+  end
+
+  it "parses 'not foo and bar'" do
+    expect(cmd.parse("not foo and bar")).to eq({left: {unary_op: "not", expression: {identifier: "foo"}}, binary_op: "and", right: {identifier: "bar"}})
+  end
+
+  it "parses '! foo and bar'" do
+    expect(cmd.parse("! foo and bar")).to eq({left: {unary_op: "!", expression: {identifier: "foo"}}, binary_op: "and", right: {identifier: "bar"}})
+  end
+
+  it "parses 'not foo && bar'" do
+    expect(cmd.parse("not foo && bar")).to eq({left: {unary_op: "not", expression: {identifier: "foo"}}, binary_op: "&&", right: {identifier: "bar"}})
+  end
+
+  it "parses '! foo && bar'" do
+    expect(cmd.parse("! foo && bar")).to eq({left: {unary_op: "!", expression: {identifier: "foo"}}, binary_op: "&&", right: {identifier: "bar"}})
+  end
+
+  it "is unable to parse ' '" do
+    expect {
+      cmd.parse(" ")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse '((()))'" do
+    expect {
+      cmd.parse("((()))")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse 'foo and'" do
+    expect {
+      cmd.parse("foo and")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse 'foo &'" do
+    expect {
+      cmd.parse("foo &")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse 'foo &&'" do
+    expect {
+      cmd.parse("foo &&")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse 'and foo'" do
+    expect {
+      cmd.parse("and foo")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse '& foo'" do
+    expect {
+      cmd.parse("& foo")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+
+  it "is unable to parse '&& foo'" do
+    expect {
+      cmd.parse("&& foo")
+    }.to raise_error(Parslet::ParseFailed)
+  end
+end

data/spec/parser/tag_expression_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "tag expression" do
+  let(:cmd) {
+    Hotdog::Commands::Search.new(Hotdog::Application.new)
+  }
+
+  it "interprets tag with host" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("host", "foo")
+    q = [
+      "SELECT hosts.id FROM hosts",
+        "WHERE hosts.name = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag with identifier and attribute" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", "bar")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.name = ? AND tags.value = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "bar"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag with identifier" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new("foo", nil)
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts.name = ? OR tags.name = ? OR tags.value = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo", "foo", "foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag with attribute" do
+    expr = Hotdog::Commands::Search::TagExpressionNode.new(nil, "foo")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.value = ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+end

data/spec/parser/tag_glob_expression_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "hotdog/application"
+require "hotdog/commands"
+require "hotdog/commands/search"
+require "parslet"
+
+describe "tag glob expression" do
+  let(:cmd) {
+    Hotdog::Commands::Search.new(Hotdog::Application.new)
+  }
+
+  it "interprets tag glob with host" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("host", "foo*")
+    q = [
+      "SELECT hosts.id FROM hosts",
+        "WHERE hosts.name GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag glob with identifier and attribute" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", "bar*")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.name GLOB ? AND tags.value GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*", "bar*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag glob with identifier" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new("foo*", nil)
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE hosts.name GLOB ? OR tags.name GLOB ? OR tags.value GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*", "foo*", "foo*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+
+  it "interprets tag glob with attribute" do
+    expr = Hotdog::Commands::Search::TagGlobExpressionNode.new(nil, "foo*")
+    q = [
+      "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+        "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+          "WHERE tags.value GLOB ?;",
+    ]
+    allow(cmd).to receive(:execute).with(q.join(" "), ["foo*"]) {
+      [[1], [2], [3]]
+    }
+    expect(expr.evaluate(cmd)).to eq([1, 2, 3])
+  end
+end