api_key 0.1.0

Generate api key in rust supports base32, base62, string, uuid4, uuid5
Documentation 
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

#![allow(dead_code)]
#[warn(unused_comparisons)]
use crate::{
  types::{
    ApiKeyResults, Base32Generator, Base62Generator, BytesGenerator, StringGenerator,
    UuidV4Generator, UuidV5Generator,
  },
  utils::Utility,
};

mod constants;
mod utils;

mod base32;
mod base62;
mod bytes;
mod string;
mod uuid4;
mod uuid5;

pub mod types;

pub fn string(options: StringGenerator) -> ApiKeyResults {
  build(options)
}

pub fn bytes(options: BytesGenerator) -> ApiKeyResults {
  build(options)
}

pub fn base32(options: Base32Generator) -> ApiKeyResults {
  build(options)
}

pub fn base62(options: Base62Generator) -> ApiKeyResults {
  build(options)
}

pub fn uuid4(options: UuidV4Generator) -> ApiKeyResults {
  build(options)
}

pub fn uuid5(options: UuidV5Generator) -> ApiKeyResults {
  build(options)
}

fn build<T: Utility>(options: T) -> ApiKeyResults {
  if options.batch_len() > 0 {
    ApiKeyResults::StringArray(Utility::batch(&options))
  } else {
    ApiKeyResults::String(options.gen())
  }
}

#[cfg(test)]
mod api_key_test {
  use crate::{
    string,
    types::{ApiKeyResults, Default, StringGenerator, UuidV4Generator},
    uuid4,
  };

  #[test]
  fn generate_batch_string_api_key() {
    let options = StringGenerator {
      length: 2,
      batch: 3,
      ..StringGenerator::default()
    };

    let key: ApiKeyResults = string(options);

    assert!(match key {
      ApiKeyResults::StringArray(d) => d.len() == 3,
      _ => false,
    })
  }

  #[test]
  fn generate_string_api_key() {
    let options = StringGenerator {
      length: 2,
      prefix: String::from("PREFIX"),
      ..StringGenerator::default()
    };

    let key: ApiKeyResults = string(options);

    assert!(match key {
      ApiKeyResults::String(d) => d.starts_with("PREFIX"),
      _ => false,
    })
  }

  #[test]
  fn generate_uuid4_api_key() {
    let options = UuidV4Generator {
      prefix: String::from("PREFIX"),
      ..UuidV4Generator::default()
    };

    let key: ApiKeyResults = uuid4(options);

    assert!(match key {
      ApiKeyResults::String(res) => res.starts_with("PREFIX") && res.contains("-"),
      _ => false,
    })
  }
}