fakecloud_dynamodb/
state.rs

1use chrono::{DateTime, Utc};
2use parking_lot::RwLock;
3use serde::{Deserialize, Serialize};
4use serde_json::Value;
5use std::collections::{BTreeMap, HashMap};
6use std::sync::Arc;
7
8fn empty_stream_records() -> Arc<RwLock<Vec<StreamRecord>>> {
9    Arc::new(RwLock::new(Vec::new()))
10}
11
12/// Serde for `Arc<RwLock<Vec<StreamRecord>>>`: persist the inner change records
13/// so a stream consumer's un-read records survive a snapshot restart
14/// (bug-audit 2026-05-28, 4.5). The field was `#[serde(skip)]`, so table data
15/// was preserved across restart but pending stream records silently vanished.
16mod stream_records_serde {
17    use super::{Arc, RwLock, StreamRecord};
18    use serde::{Deserialize, Deserializer, Serialize, Serializer};
19
20    pub fn serialize<S: Serializer>(
21        v: &Arc<RwLock<Vec<StreamRecord>>>,
22        s: S,
23    ) -> Result<S::Ok, S::Error> {
24        v.read().serialize(s)
25    }
26
27    pub fn deserialize<'de, D: Deserializer<'de>>(
28        d: D,
29    ) -> Result<Arc<RwLock<Vec<StreamRecord>>>, D::Error> {
30        let records = Vec::<StreamRecord>::deserialize(d)?;
31        // Raise the in-memory sequence-number floor above every persisted
32        // record so newly-minted numbers cannot collide with them after a
33        // restart, even if the wall-clock seed went backwards (4.4 / Cubic).
34        for r in &records {
35            crate::streams::observe_stream_sequence(&r.dynamodb.sequence_number);
36        }
37        Ok(Arc::new(RwLock::new(records)))
38    }
39}
40
41/// A single DynamoDB attribute value (tagged union matching the AWS wire format).
42/// AWS sends attribute values as `{"S": "hello"}`, `{"N": "42"}`, etc.
43pub type AttributeValue = Value;
44
45/// Extract the "typed" inner value for comparison purposes.
46/// Returns (type_tag, inner_value) e.g. ("S", "hello") or ("N", "42").
47pub fn attribute_type_and_value(av: &Value) -> Option<(&str, &Value)> {
48    let obj = av.as_object()?;
49    if obj.len() != 1 {
50        return None;
51    }
52    let (k, v) = obj.iter().next()?;
53    Some((k.as_str(), v))
54}
55
56#[derive(Debug, Clone, Serialize, Deserialize)]
57pub struct KeySchemaElement {
58    pub attribute_name: String,
59    pub key_type: String, // HASH or RANGE
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub struct AttributeDefinition {
64    pub attribute_name: String,
65    pub attribute_type: String, // S, N, B
66}
67
68#[derive(Debug, Clone, Serialize, Deserialize)]
69pub struct ProvisionedThroughput {
70    pub read_capacity_units: i64,
71    pub write_capacity_units: i64,
72}
73
74/// On-demand capacity caps for PAY_PER_REQUEST tables and GSIs. Real AWS
75/// accepts both fields independently; `-1` (the AWS sentinel for "no cap")
76/// is the default and is what `DescribeTable` returns when the caller never
77/// set a value — the Terraform provider asserts on that exact value.
78#[derive(Debug, Clone, Serialize, Deserialize)]
79pub struct OnDemandThroughput {
80    pub max_read_request_units: i64,
81    pub max_write_request_units: i64,
82}
83
84#[derive(Debug, Clone, Serialize, Deserialize)]
85pub struct GlobalSecondaryIndex {
86    pub index_name: String,
87    pub key_schema: Vec<KeySchemaElement>,
88    pub projection: Projection,
89    pub provisioned_throughput: Option<ProvisionedThroughput>,
90    pub on_demand_throughput: Option<OnDemandThroughput>,
91}
92
93#[derive(Debug, Clone, Serialize, Deserialize)]
94pub struct LocalSecondaryIndex {
95    pub index_name: String,
96    pub key_schema: Vec<KeySchemaElement>,
97    pub projection: Projection,
98}
99
100#[derive(Debug, Clone, Serialize, Deserialize)]
101pub struct Projection {
102    pub projection_type: String, // ALL, KEYS_ONLY, INCLUDE
103    pub non_key_attributes: Vec<String>,
104}
105
106#[derive(Debug, Clone, Serialize, Deserialize)]
107pub struct DynamoTable {
108    pub name: String,
109    pub arn: String,
110    pub table_id: String,
111    pub key_schema: Vec<KeySchemaElement>,
112    pub attribute_definitions: Vec<AttributeDefinition>,
113    pub provisioned_throughput: ProvisionedThroughput,
114    pub items: Vec<HashMap<String, AttributeValue>>,
115    pub gsi: Vec<GlobalSecondaryIndex>,
116    pub lsi: Vec<LocalSecondaryIndex>,
117    pub tags: BTreeMap<String, String>,
118    pub created_at: DateTime<Utc>,
119    pub status: String,
120    pub item_count: i64,
121    pub size_bytes: i64,
122    pub billing_mode: String, // PROVISIONED or PAY_PER_REQUEST
123    pub ttl_attribute: Option<String>,
124    pub ttl_enabled: bool,
125    pub resource_policy: Option<String>,
126    /// PITR enabled
127    pub pitr_enabled: bool,
128    /// Kinesis streaming destinations: stream_arn -> status
129    pub kinesis_destinations: Vec<KinesisDestination>,
130    /// Contributor insights status
131    pub contributor_insights_status: String,
132    /// Contributor insights: partition key access counters (key_value_string -> count)
133    pub contributor_insights_counters: BTreeMap<String, u64>,
134    /// DynamoDB Streams configuration
135    pub stream_enabled: bool,
136    pub stream_view_type: Option<String>, // KEYS_ONLY, NEW_IMAGE, OLD_IMAGE, NEW_AND_OLD_IMAGES
137    pub stream_arn: Option<String>,
138    /// Stream records (retained for 24 hours). Not persisted: stream
139    /// records are ephemeral and would be garbage anyway across restarts.
140    #[serde(with = "stream_records_serde", default = "empty_stream_records")]
141    pub stream_records: Arc<RwLock<Vec<StreamRecord>>>,
142    /// Server-side encryption type: AES256 (owned) or KMS
143    pub sse_type: Option<String>,
144    /// KMS key ARN for SSE (only when sse_type is KMS)
145    pub sse_kms_key_arn: Option<String>,
146    /// Deletion protection: when true, DeleteTable is rejected with
147    /// `ResourceInUseException`. Defaults to false. Returned on every
148    /// `DescribeTable` and toggleable via `UpdateTable`.
149    pub deletion_protection_enabled: bool,
150    /// Table-level on-demand throughput caps. Only meaningful for
151    /// PAY_PER_REQUEST tables, but real AWS echoes the field on every
152    /// DescribeTable once set.
153    pub on_demand_throughput: Option<OnDemandThroughput>,
154}
155
156#[derive(Debug, Clone, Serialize, Deserialize)]
157pub struct StreamRecord {
158    pub event_id: String,
159    pub event_name: String, // INSERT, MODIFY, REMOVE
160    pub event_version: String,
161    pub event_source: String,
162    pub aws_region: String,
163    pub dynamodb: DynamoDbStreamRecord,
164    pub event_source_arn: String,
165    pub timestamp: DateTime<Utc>,
166}
167
168#[derive(Debug, Clone, Serialize, Deserialize)]
169pub struct DynamoDbStreamRecord {
170    pub keys: HashMap<String, AttributeValue>,
171    pub new_image: Option<HashMap<String, AttributeValue>>,
172    pub old_image: Option<HashMap<String, AttributeValue>>,
173    pub sequence_number: String,
174    pub size_bytes: i64,
175    pub stream_view_type: String,
176}
177
178#[derive(Debug, Clone, Serialize, Deserialize)]
179pub struct KinesisDestination {
180    pub stream_arn: String,
181    pub destination_status: String,
182    pub approximate_creation_date_time_precision: String,
183}
184
185#[derive(Debug, Clone, Serialize, Deserialize)]
186pub struct BackupDescription {
187    pub backup_arn: String,
188    pub backup_name: String,
189    pub table_name: String,
190    pub table_arn: String,
191    pub backup_status: String,
192    pub backup_type: String,
193    pub backup_creation_date: DateTime<Utc>,
194    pub key_schema: Vec<KeySchemaElement>,
195    pub attribute_definitions: Vec<AttributeDefinition>,
196    pub provisioned_throughput: ProvisionedThroughput,
197    pub billing_mode: String,
198    pub item_count: i64,
199    pub size_bytes: i64,
200    /// Snapshot of the table items at backup creation time.
201    pub items: Vec<HashMap<String, AttributeValue>>,
202    /// Real DDB persists GSI/LSI/tags/TTL/SSE/Stream into the backup
203    /// payload so RestoreTableFromBackup brings the full table back
204    /// up. Older snapshots may not have these fields, so all default
205    /// to empty/false via serde.
206    #[serde(default)]
207    pub gsi: Vec<GlobalSecondaryIndex>,
208    #[serde(default)]
209    pub lsi: Vec<LocalSecondaryIndex>,
210    #[serde(default)]
211    pub tags: BTreeMap<String, String>,
212    #[serde(default)]
213    pub ttl_attribute: Option<String>,
214    #[serde(default)]
215    pub ttl_enabled: bool,
216    #[serde(default)]
217    pub sse_type: Option<String>,
218    #[serde(default)]
219    pub sse_kms_key_arn: Option<String>,
220    #[serde(default)]
221    pub stream_enabled: bool,
222    #[serde(default)]
223    pub stream_view_type: Option<String>,
224}
225
226#[derive(Debug, Clone, Serialize, Deserialize)]
227pub struct GlobalTableDescription {
228    pub global_table_name: String,
229    pub global_table_arn: String,
230    pub global_table_status: String,
231    pub creation_date: DateTime<Utc>,
232    pub replication_group: Vec<ReplicaDescription>,
233}
234
235#[derive(Debug, Clone, Serialize, Deserialize)]
236pub struct ReplicaDescription {
237    pub region_name: String,
238    pub replica_status: String,
239    /// Per-replica provisioned-read-capacity autoscaling settings, as supplied
240    /// via `UpdateTableReplicaAutoScaling`. Round-tripped through
241    /// `DescribeTableReplicaAutoScaling` as `AutoScalingSettingsDescription`.
242    #[serde(default)]
243    pub read_capacity_auto_scaling: Option<serde_json::Value>,
244    /// Per-replica provisioned-write-capacity autoscaling settings.
245    #[serde(default)]
246    pub write_capacity_auto_scaling: Option<serde_json::Value>,
247}
248
249#[derive(Debug, Clone, Serialize, Deserialize)]
250pub struct ExportDescription {
251    pub export_arn: String,
252    pub export_status: String,
253    pub table_arn: String,
254    pub s3_bucket: String,
255    pub s3_prefix: Option<String>,
256    pub export_format: String,
257    pub start_time: DateTime<Utc>,
258    pub end_time: DateTime<Utc>,
259    pub export_time: DateTime<Utc>,
260    pub item_count: i64,
261    pub billed_size_bytes: i64,
262}
263
264#[derive(Debug, Clone, Serialize, Deserialize)]
265pub struct ImportDescription {
266    pub import_arn: String,
267    pub import_status: String,
268    pub table_arn: String,
269    pub table_name: String,
270    pub s3_bucket_source: String,
271    pub input_format: String,
272    pub start_time: DateTime<Utc>,
273    pub end_time: DateTime<Utc>,
274    pub processed_item_count: i64,
275    pub processed_size_bytes: i64,
276}
277
278impl DynamoTable {
279    /// Get the hash key attribute name from the key schema.
280    pub fn hash_key_name(&self) -> &str {
281        self.key_schema
282            .iter()
283            .find(|k| k.key_type == "HASH")
284            .map(|k| k.attribute_name.as_str())
285            .unwrap_or("")
286    }
287
288    /// Get the range key attribute name from the key schema (if any).
289    pub fn range_key_name(&self) -> Option<&str> {
290        self.key_schema
291            .iter()
292            .find(|k| k.key_type == "RANGE")
293            .map(|k| k.attribute_name.as_str())
294    }
295
296    /// Find an item index by its primary key.
297    pub fn find_item_index(&self, key: &HashMap<String, AttributeValue>) -> Option<usize> {
298        let hash_key = self.hash_key_name();
299        let range_key = self.range_key_name();
300
301        self.items.iter().position(|item| {
302            let hash_match = match (item.get(hash_key), key.get(hash_key)) {
303                (Some(a), Some(b)) => a == b,
304                _ => false,
305            };
306            if !hash_match {
307                return false;
308            }
309            match range_key {
310                Some(rk) => match (item.get(rk), key.get(rk)) {
311                    (Some(a), Some(b)) => a == b,
312                    (None, None) => true,
313                    _ => false,
314                },
315                None => true,
316            }
317        })
318    }
319
320    /// Estimate item size in bytes (rough approximation).
321    fn estimate_item_size(item: &HashMap<String, AttributeValue>) -> i64 {
322        let mut size: i64 = 0;
323        for (k, v) in item {
324            size += k.len() as i64;
325            size += Self::estimate_value_size(v);
326        }
327        size
328    }
329
330    fn estimate_value_size(v: &Value) -> i64 {
331        match v {
332            Value::Object(obj) => {
333                if let Some(s) = obj.get("S").and_then(|v| v.as_str()) {
334                    s.len() as i64
335                } else if let Some(n) = obj.get("N").and_then(|v| v.as_str()) {
336                    n.len() as i64
337                } else if obj.contains_key("BOOL") || obj.contains_key("NULL") {
338                    1
339                } else if let Some(l) = obj.get("L").and_then(|v| v.as_array()) {
340                    3 + l.iter().map(Self::estimate_value_size).sum::<i64>()
341                } else if let Some(m) = obj.get("M").and_then(|v| v.as_object()) {
342                    3 + m
343                        .iter()
344                        .map(|(k, v)| k.len() as i64 + Self::estimate_value_size(v))
345                        .sum::<i64>()
346                } else if let Some(ss) = obj.get("SS").and_then(|v| v.as_array()) {
347                    ss.iter()
348                        .filter_map(|v| v.as_str())
349                        .map(|s| s.len() as i64)
350                        .sum()
351                } else if let Some(ns) = obj.get("NS").and_then(|v| v.as_array()) {
352                    ns.iter()
353                        .filter_map(|v| v.as_str())
354                        .map(|s| s.len() as i64)
355                        .sum()
356                } else if let Some(b) = obj.get("B").and_then(|v| v.as_str()) {
357                    // Base64-encoded binary
358                    (b.len() as i64 * 3) / 4
359                } else {
360                    v.to_string().len() as i64
361                }
362            }
363            _ => v.to_string().len() as i64,
364        }
365    }
366
367    /// Record a partition key access for contributor insights.
368    /// Only records if contributor insights is enabled.
369    pub fn record_key_access(&mut self, key: &HashMap<String, AttributeValue>) {
370        if self.contributor_insights_status != "ENABLED" {
371            return;
372        }
373        let hash_key = self.hash_key_name().to_string();
374        if let Some(pk_value) = key.get(&hash_key) {
375            let key_str = pk_value.to_string();
376            *self
377                .contributor_insights_counters
378                .entry(key_str)
379                .or_insert(0) += 1;
380        }
381    }
382
383    /// Record a partition key access from a full item (extracts the key first).
384    pub fn record_item_access(&mut self, item: &HashMap<String, AttributeValue>) {
385        if self.contributor_insights_status != "ENABLED" {
386            return;
387        }
388        let hash_key = self.hash_key_name().to_string();
389        if let Some(pk_value) = item.get(&hash_key) {
390            let key_str = pk_value.to_string();
391            *self
392                .contributor_insights_counters
393                .entry(key_str)
394                .or_insert(0) += 1;
395        }
396    }
397
398    /// Get top N contributors sorted by access count (descending).
399    pub fn top_contributors(&self, n: usize) -> Vec<(&str, u64)> {
400        let mut entries: Vec<(&str, u64)> = self
401            .contributor_insights_counters
402            .iter()
403            .map(|(k, &v)| (k.as_str(), v))
404            .collect();
405        entries.sort_by_key(|e| std::cmp::Reverse(e.1));
406        entries.truncate(n);
407        entries
408    }
409
410    /// Recalculate item_count and size_bytes from the items vec.
411    pub fn recalculate_stats(&mut self) {
412        self.item_count = self.items.len() as i64;
413        self.size_bytes = self.items.iter().map(Self::estimate_item_size).sum::<i64>();
414    }
415}
416
417#[derive(Debug, Clone, Serialize, Deserialize)]
418pub struct DynamoDbState {
419    pub account_id: String,
420    pub region: String,
421    pub tables: BTreeMap<String, DynamoTable>,
422    pub backups: BTreeMap<String, BackupDescription>,
423    pub global_tables: BTreeMap<String, GlobalTableDescription>,
424    pub exports: BTreeMap<String, ExportDescription>,
425    pub imports: BTreeMap<String, ImportDescription>,
426}
427
428/// On-disk snapshot envelope. The payload is the full [`DynamoDbState`];
429/// `schema_version` lets us evolve the format without accidentally loading
430/// an incompatible dump on upgrade.
431#[derive(Debug, Clone, Serialize, Deserialize)]
432pub struct DynamoDbSnapshot {
433    pub schema_version: u32,
434    /// v2+: multi-account state.
435    #[serde(default)]
436    pub accounts: Option<fakecloud_core::multi_account::MultiAccountState<DynamoDbState>>,
437    /// v1 compat: single-account state.
438    #[serde(default)]
439    pub state: Option<DynamoDbState>,
440}
441
442pub const DYNAMODB_SNAPSHOT_SCHEMA_VERSION: u32 = 2;
443
444impl DynamoDbState {
445    pub fn new(account_id: &str, region: &str) -> Self {
446        Self {
447            account_id: account_id.to_string(),
448            region: region.to_string(),
449            tables: BTreeMap::new(),
450            backups: BTreeMap::new(),
451            global_tables: BTreeMap::new(),
452            exports: BTreeMap::new(),
453            imports: BTreeMap::new(),
454        }
455    }
456
457    pub fn reset(&mut self) {
458        self.tables.clear();
459        self.backups.clear();
460        self.global_tables.clear();
461        self.exports.clear();
462        self.imports.clear();
463    }
464}
465
466impl fakecloud_core::multi_account::AccountState for DynamoDbState {
467    fn new_for_account(account_id: &str, region: &str, _endpoint: &str) -> Self {
468        Self::new(account_id, region)
469    }
470}
471
472pub type SharedDynamoDbState =
473    Arc<RwLock<fakecloud_core::multi_account::MultiAccountState<DynamoDbState>>>;
474
475#[cfg(test)]
476mod tests {
477    use super::*;
478    use serde_json::json;
479
480    #[test]
481    fn attribute_type_and_value_valid() {
482        let v = json!({"S": "hi"});
483        let (ty, val) = attribute_type_and_value(&v).unwrap();
484        assert_eq!(ty, "S");
485        assert_eq!(val, &json!("hi"));
486    }
487
488    #[test]
489    fn attribute_type_and_value_empty_returns_none() {
490        let v = json!({});
491        assert!(attribute_type_and_value(&v).is_none());
492    }
493
494    #[test]
495    fn attribute_type_and_value_multiple_entries_returns_none() {
496        let v = json!({"S": "hi", "N": "1"});
497        assert!(attribute_type_and_value(&v).is_none());
498    }
499
500    #[test]
501    fn attribute_type_and_value_non_object_returns_none() {
502        let v = json!("not-object");
503        assert!(attribute_type_and_value(&v).is_none());
504    }
505
506    #[test]
507    fn account_state_trait_impl() {
508        use fakecloud_core::multi_account::AccountState;
509        let state = DynamoDbState::new_for_account("123", "us-east-1", "");
510        assert_eq!(state.account_id, "123");
511        assert_eq!(state.region, "us-east-1");
512    }
513
514    #[test]
515    fn new_and_reset() {
516        let state = DynamoDbState::new("123", "us-east-1");
517        assert!(state.tables.is_empty());
518    }
519
520    fn table_with_hash_key(hash: &str) -> DynamoTable {
521        DynamoTable {
522            name: "t".to_string(),
523            arn: "arn:aws:dynamodb:us-east-1:123:table/t".to_string(),
524            table_id: "id".to_string(),
525            key_schema: vec![KeySchemaElement {
526                attribute_name: hash.to_string(),
527                key_type: "HASH".to_string(),
528            }],
529            attribute_definitions: vec![],
530            provisioned_throughput: ProvisionedThroughput {
531                read_capacity_units: 1,
532                write_capacity_units: 1,
533            },
534            items: Vec::new(),
535            gsi: Vec::new(),
536            lsi: Vec::new(),
537            tags: BTreeMap::new(),
538            created_at: Utc::now(),
539            status: "ACTIVE".to_string(),
540            item_count: 0,
541            size_bytes: 0,
542            billing_mode: "PROVISIONED".to_string(),
543            ttl_attribute: None,
544            ttl_enabled: false,
545            resource_policy: None,
546            pitr_enabled: false,
547            kinesis_destinations: Vec::new(),
548            contributor_insights_status: "DISABLED".to_string(),
549            contributor_insights_counters: BTreeMap::new(),
550            stream_enabled: false,
551            stream_view_type: None,
552            stream_arn: None,
553            stream_records: empty_stream_records(),
554            sse_type: None,
555            sse_kms_key_arn: None,
556            deletion_protection_enabled: false,
557            on_demand_throughput: None,
558        }
559    }
560
561    #[test]
562    fn hash_key_name_extracts_from_schema() {
563        let t = table_with_hash_key("pk");
564        assert_eq!(t.hash_key_name(), "pk");
565    }
566
567    #[test]
568    fn hash_key_name_empty_when_no_hash_schema() {
569        let mut t = table_with_hash_key("pk");
570        t.key_schema.clear();
571        assert_eq!(t.hash_key_name(), "");
572    }
573
574    #[test]
575    fn record_key_access_noop_when_disabled() {
576        let mut t = table_with_hash_key("pk");
577        let mut key = HashMap::new();
578        key.insert("pk".to_string(), json!({"S": "a"}));
579        t.record_key_access(&key);
580        assert!(t.contributor_insights_counters.is_empty());
581    }
582
583    #[test]
584    fn record_key_access_increments_when_enabled() {
585        let mut t = table_with_hash_key("pk");
586        t.contributor_insights_status = "ENABLED".to_string();
587        let mut key = HashMap::new();
588        key.insert("pk".to_string(), json!({"S": "a"}));
589        t.record_key_access(&key);
590        t.record_key_access(&key);
591        assert_eq!(t.contributor_insights_counters.values().sum::<u64>(), 2);
592    }
593
594    #[test]
595    fn record_item_access_uses_hash_key_from_item() {
596        let mut t = table_with_hash_key("pk");
597        t.contributor_insights_status = "ENABLED".to_string();
598        let mut item = HashMap::new();
599        item.insert("pk".to_string(), json!({"S": "user-1"}));
600        item.insert("other".to_string(), json!({"N": "42"}));
601        t.record_item_access(&item);
602        assert_eq!(t.contributor_insights_counters.values().sum::<u64>(), 1);
603    }
604
605    #[test]
606    fn top_contributors_returns_sorted() {
607        let mut t = table_with_hash_key("pk");
608        t.contributor_insights_counters.insert("a".to_string(), 3);
609        t.contributor_insights_counters.insert("b".to_string(), 10);
610        t.contributor_insights_counters.insert("c".to_string(), 1);
611        let top = t.top_contributors(2);
612        assert_eq!(top.len(), 2);
613        assert_eq!(top[0], ("b", 10));
614        assert_eq!(top[1], ("a", 3));
615    }
616
617    #[test]
618    fn recalculate_stats_matches_items() {
619        let mut t = table_with_hash_key("pk");
620        let mut item1 = HashMap::new();
621        item1.insert("pk".to_string(), json!({"S": "hello"}));
622        let mut item2 = HashMap::new();
623        item2.insert("pk".to_string(), json!({"N": "42"}));
624        item2.insert("flag".to_string(), json!({"BOOL": true}));
625        t.items.push(item1);
626        t.items.push(item2);
627        t.recalculate_stats();
628        assert_eq!(t.item_count, 2);
629        assert!(t.size_bytes > 0);
630    }
631
632    #[test]
633    fn estimate_value_size_covers_all_types() {
634        let s = DynamoTable::estimate_value_size(&json!({"S": "abc"}));
635        assert_eq!(s, 3);
636        let n = DynamoTable::estimate_value_size(&json!({"N": "42"}));
637        assert_eq!(n, 2);
638        let b = DynamoTable::estimate_value_size(&json!({"BOOL": true}));
639        assert_eq!(b, 1);
640        let null = DynamoTable::estimate_value_size(&json!({"NULL": true}));
641        assert_eq!(null, 1);
642        let l = DynamoTable::estimate_value_size(&json!({"L": [{"S": "x"}, {"S": "yy"}]}));
643        assert_eq!(l, 6);
644        let m = DynamoTable::estimate_value_size(&json!({"M": {"key": {"S": "v"}}}));
645        assert_eq!(m, 7);
646        let ss = DynamoTable::estimate_value_size(&json!({"SS": ["ab", "cde"]}));
647        assert_eq!(ss, 5);
648        let ns = DynamoTable::estimate_value_size(&json!({"NS": ["12", "345"]}));
649        assert_eq!(ns, 5);
650        let bin = DynamoTable::estimate_value_size(&json!({"B": "AAAAAAAA"}));
651        assert_eq!(bin, 6);
652    }
653}
fakecloud_dynamodb/state.rs

fakecloud_dynamodb/
state.rs
