2089795741

Build # 2089795741

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/tremor-rs/tremor-runtime/commit/<a class=hub.com/tremor-rs/tremor-runtime/commit/4ad0f034ab43d28068bf8877e3753451b62a4e5e">4ad0f034a<a href="https://github.com/tremor-rs/tremor-runtime/commit/4ad0f034ab43d28068bf8877e3753451b62a4e5e">">Merge </a><a class="double-link" href="https://github.com/tremor-rs/tremor-runtime/commit/<a class="double-link" href="https://github.com/tremor-rs/tremor-runtime/commit/00824b7ba72abe54524e237ba200c2345743d499">00824b7ba</a>">00824b7ba</a><a href="https://github.com/tremor-rs/tremor-runtime/commit/4ad0f034ab43d28068bf8877e3753451b62a4e5e"> into ca5234b15">ca5234b15</a>

Pull Request Pull Request #1077: Connectors Implementation

Run Details

14221 of 14221 new or added lines in 164 files covered. (100.0%)

23738 of 27356 relevant lines covered (86.77%)

3.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.55

/tremor-script/src/std_lib/random.rs

// Copyright 2020-2021, The Tremor Team
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::prelude::*;
use crate::registry::{mfa, FResult, FunctionError, Registry, TremorFn, TremorFnWrapper};
use crate::tremor_fn;
use crate::EventContext;
use crate::Value;
use rand::distributions::Alphanumeric;
use rand::{rngs::SmallRng, Rng, SeedableRng};

// TODO see if we can cache the RNG here across function calls (or at least
// at the thread level, like via rand::thread_rng()
//
// also, `rng.gen_range()` calls here are optimized for a single sample from
// the range. we will be sampling a lot during a typical use case, so swap it
// for a distribution based sampling (if we can cache the distribution):
// https://docs.rs/rand/0.7.0/rand/trait.Rng.html#method.gen_range
#[derive(Clone, Debug, Default)]
struct RandomInteger {}
impl TremorFn for RandomInteger {
    fn invoke<'event, 'c>(
        &self,
        ctx: &'c EventContext,
        args: &[&Value<'event>],
    ) -> FResult<Value<'event>> {
        let this_mfa = || mfa("random", "integer", args.len());
        // TODO add event id to the seed? also change ingest_ns() for tremor-script binary runs too
        let mut rng = SmallRng::seed_from_u64(ctx.ingest_ns());
        match args {
            [low, high] => {
                if let (Some(low), Some(high)) = (low.as_i64(), high.as_i64()) {
                    if low < high {
                        // random integer between low and high (not including high)
                        Ok(Value::from(rng.gen_range(low..high)))
                    } else {
                        Err(FunctionError::RuntimeError {
                                mfa: this_mfa(),
                                error:
                                    "Invalid arguments. First argument must be lower than second argument".to_string(),
                            })
                    }
                } else {
                    Err(FunctionError::BadType { mfa: this_mfa() })
                }
            }
            [input] => {
                input.as_u64().map_or_else(
                    || Err(FunctionError::BadType { mfa: this_mfa() }),
                    |input| {
                        if input == 0 {
                            // avoid panic in gen_range
                            Err(FunctionError::RuntimeError {
                                mfa: this_mfa(),
                                error: "Invalid arguments. Single argument value must be > 0."
                                    .to_string(),
                            })
                        } else {
                            // random integer between 0 and input (not including input)
                            Ok(Value::from(rng.gen_range(0..input)))
                        }
                    },
                )
            }
            [] => Ok(Value::from(
                rng.gen::<i64>(), // random integer
            )),
            _ => Err(FunctionError::BadArity {
                mfa: this_mfa(),
                calling_a: args.len(),
            }),
        }
    }
    fn boxed_clone(&self) -> Box<dyn TremorFn> {
        Box::new(self.clone())
    }
    fn arity(&self) -> std::ops::RangeInclusive<usize> {
        0..=2
    }
    fn is_const(&self) -> bool {
        false
    }
}
// TODO try to consolidate this with the integer implementation -- mostly a copy-pasta
// of that right now, with types changed
#[derive(Clone, Debug, Default)]
struct RandomFloat {}
impl TremorFn for RandomFloat {
    fn invoke<'event, 'c>(
        &self,
        ctx: &'c EventContext,
        args: &[&Value<'event>],
    ) -> FResult<Value<'event>> {
        let this_mfa = || mfa("random", "float", args.len());
        let mut rng = SmallRng::seed_from_u64(ctx.ingest_ns());
        match args {
            [low, high] => {
                if let (Some(low), Some(high)) = (low.cast_f64(), high.cast_f64()) {
                    if low < high {
                        // random integer between low and high (not including high)
                        Ok(Value::from(rng.gen_range(low..high)))
                    } else {
                        Err(FunctionError::RuntimeError {
                                mfa: this_mfa(),
                                error:
                                    "Invalid arguments. First argument must be lower than second argument".to_string(),
                            })
                    }
                } else {
                    Err(FunctionError::BadType { mfa: this_mfa() })
                }
            }
            [input] => {
                input.cast_f64().map_or_else(
                    || Err(FunctionError::BadType { mfa: this_mfa() }),
                    |input| {
                        if input <= 0.0 {
                            // avoid panic in gen_range
                            Err(FunctionError::RuntimeError {
                                mfa: this_mfa(),
                                error: "Invalid arguments. Single argument value must be > 0.0."
                                    .to_string(),
                            })
                        } else {
                            // random integer between 0 and input (not including input)
                            Ok(Value::from(rng.gen_range(0.0..input)))
                        }
                    },
                )
            }
            [] => Ok(Value::from(
                rng.gen::<f64>(), // random integer
            )),
            _ => Err(FunctionError::BadArity {
                mfa: this_mfa(),
                calling_a: args.len(),
            }),
        }
    }

    fn boxed_clone(&self) -> Box<dyn TremorFn> {
        Box::new(self.clone())
    }
    fn arity(&self) -> std::ops::RangeInclusive<usize> {
        0..=2
    }
    fn is_const(&self) -> bool {
        false
    }
}

pub fn load(registry: &mut Registry) {
    registry
        .insert(tremor_fn! (random|bool(_context) {
            Ok(Value::from(
                SmallRng::seed_from_u64(_context.ingest_ns())
                    .gen::<bool>()
            ))
        }))
        // TODO support specifying range of characters as a second (optional) arg
        .insert(tremor_fn! (random|string(_context, _length) {
            _length.as_usize().map_or_else(
                ||Err(FunctionError::BadType{mfa: this_mfa()}),
                |n| {
                // random string with chars uniformly distributed over ASCII letters and numbers
                Ok(Value::from(
                 SmallRng::seed_from_u64(_context.ingest_ns())
                    .sample_iter(&Alphanumeric).map(char::from).take(n).collect::<String>()
                ))
                }
            )
        }))
        .insert(TremorFnWrapper::new(
            "random".to_string(),
            "integer".to_string(),
            Box::new(RandomInteger::default()),
        ))
        .insert(TremorFnWrapper::new(
            "random".to_string(),
            "float".to_string(),
            Box::new(RandomFloat::default()),
        ));
}

#[cfg(test)]
mod test {
    use crate::registry::fun;
    use crate::Value;
    use proptest::prelude::*;
    use simd_json::prelude::*;

    #[test]
    fn bool() {
        let f = fun("random", "bool");
        assert!(f(&[]).ok().map(|v| v.is_bool()).unwrap_or_default());
    }

    #[test]
    fn string() {
        let f = fun("random", "string");
        let n = 0;
        assert_val!(f(&[&Value::from(n)]), "");
        let n = 16;
        assert!(match f(&[&Value::from(n)]) {
            Ok(Value::String(s)) => s.len() as i64 == n,
            _ => false,
        });
    }

    #[test]
    fn integer() {
        let f = fun("random", "integer");
        let v1 = Value::from(0);
        let v2 = Value::from(1);
        assert_val!(f(&[&v1, &v2]), 0);
        let v1 = Value::from(-42);
        let v2 = Value::from(-41);
        assert_val!(f(&[&v1, &v2]), -42);
        let v = Value::from(1);
        assert_val!(f(&[&v]), 0);
        assert!(f(&[]).ok().map(|v| v.is_i64()).unwrap_or_default());
        let null = Value::from(0);
        assert!(f(&[&null]).is_err());
    }

    proptest! {

        #[test]
        fn integer_single_arg_no_error(x in 1_u64..u64::MAX) { // exclude 0 here
            let f = fun("random", "integer");
            let v = Value::from(x);
            assert!(f(&[&v]).is_ok())
        }
    }

    #[test]
    fn float() {
        let f = fun("random", "float");
        let v1 = 0.0;
        let v2 = 100.0;
        assert!(f(&[&Value::from(v1), &Value::from(v2)])
            .ok()
            .as_f64()
            .map(|a| a >= v1 && a < v2)
            .unwrap_or_default());
        let v = 100.0;
        assert!(f(&[&Value::from(v)])
            .ok()
            .as_f64()
            .map(|a| a >= 0.0 && a < v)
            .unwrap_or_default());
        let null = Value::from(0.0);
        assert!(f(&[&null]).is_err());
        assert!(f(&[])
            .ok()
            .as_f64()
            .map(|a| (0.0..1.0).contains(&a))
            .unwrap_or_default());
    }

    proptest! {
        #[test]
        fn float_single_arg_no_error(x in (0.0_f64..f64::MAX).prop_filter("Values must be > 0.0", |x| *x > 0.0)) {
            let f = fun("random", "float");
            let v = Value::from(x);
            assert!(f(&[&v]).is_ok())
        }
    }
}

1	// Copyright 2020-2021, The Tremor Team
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	use crate::prelude::*;
16	use crate::registry::{mfa, FResult, FunctionError, Registry, TremorFn, TremorFnWrapper};
17	use crate::tremor_fn;
18	use crate::EventContext;
19	use crate::Value;
20	use rand::distributions::Alphanumeric;
21	use rand::{rngs::SmallRng, Rng, SeedableRng};
22
23	// TODO see if we can cache the RNG here across function calls (or at least
24	// at the thread level, like via rand::thread_rng()
25	//
26	// also, `rng.gen_range()` calls here are optimized for a single sample from
27	// the range. we will be sampling a lot during a typical use case, so swap it
28	// for a distribution based sampling (if we can cache the distribution):
29	// https://docs.rs/rand/0.7.0/rand/trait.Rng.html#method.gen_range
30	#[derive(Clone, Debug, Default)]
31	struct RandomInteger {}
32	impl TremorFn for RandomInteger {
33	fn invoke<'event, 'c>(	1✔
34	&self,
35	ctx: &'c EventContext,
36	args: &[&Value<'event>],
37	) -> FResult<Value<'event>> {
38	let this_mfa = \|\| mfa("random", "integer", args.len());	3✔
39	// TODO add event id to the seed? also change ingest_ns() for tremor-script binary runs too
40	let mut rng = SmallRng::seed_from_u64(ctx.ingest_ns());	1✔
41	match args {	×
42	[low, high] => {	2✔
43	if let (Some(low), Some(high)) = (low.as_i64(), high.as_i64()) {	2✔
44	if low < high {	2✔
45	// random integer between low and high (not including high)
46	Ok(Value::from(rng.gen_range(low..high)))	1✔
47	} else {
48	Err(FunctionError::RuntimeError {	×
49	mfa: this_mfa(),	×
50	error:	×
51	"Invalid arguments. First argument must be lower than second argument".to_string(),	×
52	})
53	}
54	} else {
55	Err(FunctionError::BadType { mfa: this_mfa() })	×
56	}
57	}
58	[input] => {	2✔
59	input.as_u64().map_or_else(	2✔
60	\|\| Err(FunctionError::BadType { mfa: this_mfa() }),	1✔
61	\|input\| {	2✔
62	if input == 0 {	2✔
63	// avoid panic in gen_range
64	Err(FunctionError::RuntimeError {	1✔
65	mfa: this_mfa(),	1✔
66	error: "Invalid arguments. Single argument value must be > 0."	1✔
67	.to_string(),	×
68	})
69	} else {
70	// random integer between 0 and input (not including input)
71	Ok(Value::from(rng.gen_range(0..input)))	1✔
72	}
73	},
74	)
75	}
76	[] => Ok(Value::from(	2✔
77	rng.gen::<i64>(), // random integer	1✔
78	)),
79	_ => Err(FunctionError::BadArity {	×
80	mfa: this_mfa(),	×
81	calling_a: args.len(),	×
82	}),
83	}
84	}
85	fn boxed_clone(&self) -> Box<dyn TremorFn> {	3✔
86	Box::new(self.clone())	3✔
87	}
88	fn arity(&self) -> std::ops::RangeInclusive<usize> {	×
89	0..=2	×
90	}
91	fn is_const(&self) -> bool {	1✔
92	false
93	}
94	}
95	// TODO try to consolidate this with the integer implementation -- mostly a copy-pasta
96	// of that right now, with types changed
97	#[derive(Clone, Debug, Default)]
98	struct RandomFloat {}
99	impl TremorFn for RandomFloat {
100	fn invoke<'event, 'c>(	1✔
101	&self,
102	ctx: &'c EventContext,
103	args: &[&Value<'event>],
104	) -> FResult<Value<'event>> {
105	let this_mfa = \|\| mfa("random", "float", args.len());	3✔
106	let mut rng = SmallRng::seed_from_u64(ctx.ingest_ns());	2✔
107	match args {	×
108	[low, high] => {	3✔
109	if let (Some(low), Some(high)) = (low.cast_f64(), high.cast_f64()) {	2✔
110	if low < high {	2✔
111	// random integer between low and high (not including high)
112	Ok(Value::from(rng.gen_range(low..high)))	1✔
113	} else {
114	Err(FunctionError::RuntimeError {	×
115	mfa: this_mfa(),	×
116	error:	×
117	"Invalid arguments. First argument must be lower than second argument".to_string(),	×
118	})
119	}
120	} else {
121	Err(FunctionError::BadType { mfa: this_mfa() })	×
122	}
123	}
124	[input] => {	2✔
125	input.cast_f64().map_or_else(	2✔
126	\|\| Err(FunctionError::BadType { mfa: this_mfa() }),	1✔
127	\|input\| {	2✔
128	if input <= 0.0 {	3✔
129	// avoid panic in gen_range
130	Err(FunctionError::RuntimeError {	1✔
131	mfa: this_mfa(),	1✔
132	error: "Invalid arguments. Single argument value must be > 0.0."	1✔
133	.to_string(),	×
134	})
135	} else {
136	// random integer between 0 and input (not including input)
137	Ok(Value::from(rng.gen_range(0.0..input)))	2✔
138	}
139	},
140	)
141	}
142	[] => Ok(Value::from(	2✔
143	rng.gen::<f64>(), // random integer	1✔
144	)),
145	_ => Err(FunctionError::BadArity {	×
146	mfa: this_mfa(),	×
147	calling_a: args.len(),	×
148	}),
149	}
150	}
151
152	fn boxed_clone(&self) -> Box<dyn TremorFn> {	3✔
153	Box::new(self.clone())	3✔
154	}
155	fn arity(&self) -> std::ops::RangeInclusive<usize> {	×
156	0..=2	×
157	}
158	fn is_const(&self) -> bool {	×
159	false
160	}
161	}
162
163	pub fn load(registry: &mut Registry) {	15✔
164	registry	75✔
165	.insert(tremor_fn! (random\|bool(_context) {	15✔
166	Ok(Value::from(	1✔
167	SmallRng::seed_from_u64(_context.ingest_ns())	1✔
168	.gen::<bool>()
169	))
170	}))
171	// TODO support specifying range of characters as a second (optional) arg
172	.insert(tremor_fn! (random\|string(_context, _length) {	15✔
173	_length.as_usize().map_or_else(	2✔
174	\|\|Err(FunctionError::BadType{mfa: this_mfa()}),	×
175	\|n\| {	2✔
176	// random string with chars uniformly distributed over ASCII letters and numbers
177	Ok(Value::from(	1✔
178	SmallRng::seed_from_u64(_context.ingest_ns())	1✔
179	.sample_iter(&Alphanumeric).map(char::from).take(n).collect::<String>()
180	))
181	}
182	)
183	}))
184	.insert(TremorFnWrapper::new(	15✔
185	"random".to_string(),	15✔
186	"integer".to_string(),	15✔
187	Box::new(RandomInteger::default()),	15✔
188	))
189	.insert(TremorFnWrapper::new(	15✔
190	"random".to_string(),	15✔
191	"float".to_string(),	15✔
192	Box::new(RandomFloat::default()),	15✔
193	));
194	}
195
196	#[cfg(test)]
197	mod test {
198	use crate::registry::fun;
199	use crate::Value;
200	use proptest::prelude::*;
201	use simd_json::prelude::*;
202
203	#[test]
204	fn bool() {	3✔
205	let f = fun("random", "bool");	1✔
206	assert!(f(&[]).ok().map(\|v\| v.is_bool()).unwrap_or_default());	4✔
207	}
208
209	#[test]
210	fn string() {	3✔
211	let f = fun("random", "string");	1✔
212	let n = 0;	1✔
213	assert_val!(f(&[&Value::from(n)]), "");	2✔
214	let n = 16;	1✔
215	assert!(match f(&[&Value::from(n)]) {	2✔
216	Ok(Value::String(s)) => s.len() as i64 == n,	2✔
217	_ => false,	×
218	});
219	}
220
221	#[test]
222	fn integer() {	3✔
223	let f = fun("random", "integer");	1✔
224	let v1 = Value::from(0);	1✔
225	let v2 = Value::from(1);	1✔
226	assert_val!(f(&[&v1, &v2]), 0);	3✔
227	let v1 = Value::from(-42);	1✔
228	let v2 = Value::from(-41);	1✔
229	assert_val!(f(&[&v1, &v2]), -42);	3✔
230	let v = Value::from(1);	1✔
231	assert_val!(f(&[&v]), 0);	2✔
232	assert!(f(&[]).ok().map(\|v\| v.is_i64()).unwrap_or_default());	3✔
233	let null = Value::from(0);	1✔
234	assert!(f(&[&null]).is_err());	2✔
235	}
236
237	proptest! {	1✔
238
239	#[test]
240	fn integer_single_arg_no_error(x in 1_u64..u64::MAX) { // exclude 0 here	2✔
241	let f = fun("random", "integer");	1✔
242	let v = Value::from(x);	1✔
243	assert!(f(&[&v]).is_ok())	3✔
244	}
245	}
246
247	#[test]
248	fn float() {	3✔
249	let f = fun("random", "float");	1✔
250	let v1 = 0.0;	1✔
251	let v2 = 100.0;	1✔
252	assert!(f(&[&Value::from(v1), &Value::from(v2)])	3✔
253	.ok()
254	.as_f64()
255	.map(\|a\| a >= v1 && a < v2)	3✔
256	.unwrap_or_default());
257	let v = 100.0;	1✔
258	assert!(f(&[&Value::from(v)])	3✔
259	.ok()
260	.as_f64()
261	.map(\|a\| a >= 0.0 && a < v)	3✔
262	.unwrap_or_default());
263	let null = Value::from(0.0);	1✔
264	assert!(f(&[&null]).is_err());	2✔
265	assert!(f(&[])	2✔
266	.ok()
267	.as_f64()
268	.map(\|a\| (0.0..1.0).contains(&a))	2✔
269	.unwrap_or_default());
270	}
271
272	proptest! {	1✔
273	#[test]
274	fn float_single_arg_no_error(x in (0.0_f64..f64::MAX).prop_filter("Values must be > 0.0", \|x\| *x > 0.0)) {	4✔
275	let f = fun("random", "float");	1✔
276	let v = Value::from(x);	1✔
277	assert!(f(&[&v]).is_ok())	3✔
278	}
279	}
280	}

tremor-rs / tremor-runtime / 2089795741

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous