File: op_query_spec.rb

package info (click to toggle)
ruby-mongo 2.5.1-2
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 4,332 kB
  • sloc: ruby: 45,579; makefile: 5
file content (154 lines) | stat: -rw-r--r-- 3,458 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
require 'spec_helper'

describe Mongo::Collection::View::Builder::OpQuery do

  describe '#specification' do

    let(:filter) do
      { 'name' => 'test' }
    end

    let(:builder) do
      described_class.new(view)
    end

    let(:specification) do
      builder.specification
    end

    let(:view) do
      Mongo::Collection::View.new(authorized_collection, filter, options)
    end

    context 'when there are modifiers in the options' do

      let(:options) do
        {
          sort: { _id: 1 },
          projection: { name: 1 },
          hint: { name: 1 },
          skip: 10,
          limit: 20,
          batch_size: 5,
          single_batch: false,
          comment: "testing",
          max_scan: 200,
          max_time_ms: 40,
          max_value: { name: 'joe' },
          min_value: { name: 'albert' },
          return_key: true,
          show_disk_loc: true,
          snapshot: true,
          tailable: true,
          oplog_replay: true,
          no_cursor_timeout: true,
          tailable_await: true,
          allow_partial_results: true,
          read_concern: { level: 'local' }
        }
      end

      let(:selector) do
        specification[:selector]
      end

      let(:opts) do
        specification[:options]
      end

      let(:flags) do
        opts[:flags]
      end

      it 'maps the collection name' do
        expect(specification[:coll_name]).to eq(authorized_collection.name)
      end

      it 'maps the filter' do
        expect(selector['$query']).to eq(filter)
      end

      it 'maps sort' do
        expect(selector['$orderby']).to eq('_id' => 1)
      end

      it 'maps projection' do
        expect(opts['project']).to eq('name' => 1)
      end

      it 'maps hint' do
        expect(selector['$hint']).to eq('name' => 1)
      end

      it 'maps skip' do
        expect(opts['skip']).to eq(10)
      end

      it 'maps limit' do
        expect(opts['limit']).to eq(20)
      end

      it 'maps batch size' do
        expect(opts['batch_size']).to eq(5)
      end

      it 'maps comment' do
        expect(selector['$comment']).to eq('testing')
      end

      it 'maps max scan' do
        expect(selector['$maxScan']).to eq(200)
      end

      it 'maps max time ms' do
        expect(selector['$maxTimeMS']).to eq(40)
      end

      it 'maps max' do
        expect(selector['$max']).to eq('name' => 'joe')
      end

      it 'maps min' do
        expect(selector['$min']).to eq('name' => 'albert')
      end

      it 'does not map read concern' do
        expect(selector['$readConcern']).to be_nil
        expect(selector['readConcern']).to be_nil
        expect(opts['readConcern']).to be_nil
      end

      it 'maps return key' do
        expect(selector['$returnKey']).to be true
      end

      it 'maps show record id' do
        expect(selector['$showDiskLoc']).to be true
      end

      it 'maps snapshot' do
        expect(selector['$snapshot']).to be true
      end

      it 'maps tailable' do
        expect(flags).to include(:tailable_cursor)
      end

      it 'maps oplog replay' do
        expect(flags).to include(:oplog_replay)
      end

      it 'maps no cursor timeout' do
        expect(flags).to include(:no_cursor_timeout)
      end

      it 'maps await data' do
        expect(flags).to include(:await_data)
      end

      it 'maps allow partial results' do
        expect(flags).to include(:partial)
      end
    end
  end
end